windows form application in c# with database pdf : Add hyperlink to pdf acrobat control Library platform web page asp.net html web browser 56EAEd010-part1938

General rights 
Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners 
and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. 
Users may download and print one copy of any publication from the public portal for the purpose of private study or research. 
You may not further distribute the material or use it for any profit-making activity or commercial gain 
You may freely distribute the URL identifying the publication in the public portal ? 
If you believe that this document breaches copyright please contact us providing details, and we will remove access to the work immediately 
and investigate your claim. 
Downloaded from orbit.dtu.dk on: May 20, 2016
The Universal Primer - An open source solution for archiving, organizing and
streaming live lectures
Christoffersen, Marc Juul; Panton, Hans Christian Hansen; Krajowski-Kukiel, Maciej; Fotel, David
Christian Askirk; Madsen, Henrik; Lassen, Janne Kofod; Haarlev Olsen, Povl Ole; Christiansen, Lasse
Engbo
Published in:
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20
- 23, 2011
DOI:
10.4122/1.1000054537
Publication date:
2011
Document Version
Publisher's PDF, also known as Version of record
Link to publication
Citation (APA):
Christoffersen, M. J., Panton, H. C. H., Krajowski-Kukiel, M., Fotel, D. C. A., Madsen, H., Lassen, J. K., ...
Christiansen, L. E. (2011). The Universal Primer - An open source solution for archiving, organizing and
streaming live lectures. In Proceedings of the 7th International CDIO Conference, Technical University of
Denmark, Copenhagen, June 20 - 23, 2011. Lyngby: Technical University of Denmark. 10.4122/1.1000054537
Add hyperlink to pdf acrobat - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
pdf hyperlinks; check links in pdf
Add hyperlink to pdf acrobat - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
adding hyperlinks to pdf documents; add links pdf document
THE UNIVERSAL PRIMER: AN OPEN SOURCE SOLUTION FOR 
ARCHIVING, ORGANIZING AND STREAMING LIVE LECTURES
Marc Juul Christoffersen, Maciej Krajowski-Kukiel, Christian Panton, David Christian 
Askirk Fotel, Henrik Madsen, Lasse Engbo Christiansen, Povl Ole Haarlev Olsen, 
Halfdan Mouritzen and Janne Kofod Lassen
Technical University of Denmark
ABSTRACT
Many disparate projects providing open access to educational videos are currently available 
or under development. These projects lack a unifying interface for accessing content, employ 
differing content licenses, and provide little or no infrastructure for user-contribution or live 
teaching. The goal of the Universal Primer is to address these problems, and allow anyone, 
anywhere, to teach or learn anything that can be reasonably taught or learned through a 
computer. The Universal Primer is 1: A fully open source solution for streaming live lectures. 
And 2: A Wikipedia-like website for uploading and organizing open-licensed community-
contributed educational material. 
KEYWORDS
online, video, streaming, community, open-source.
PROJECT SCOPE AND REQUIREMENTS
The Universal Primer attempts to solve a very large problem, in essence, creating a system 
for free access to computer-based education to the fullest extent possible. Fully meeting this 
challenge will take a lot of time and resources, yet building even a small part of the whole 
system could present a valuable contribution to free and open education. This describes the 
result of a phase one, or version 0.1 of an ongoing project. 
The project was split into two main sub-projects, with the goal of future integration:
1. The live-lecture project: Facilitating live interactive teaching.
2. The wiki-site project: Giving access to prerecorded material.
The scope of the first phase of the project was limited to focus mainly on video and tightly 
coupled materials such as lecture slides, as this was seen as the most challenging 
immediate priority. It is the future goal of the project to include support for formats such as 
Wikipedia-like web-pages, typeset documents and interactive components.
The primary goal of the first phase was specified in the form of a use-case: Use the Universal 
Primer to teach a traditional university classroom lecture in a statistics course. This goal was 
then expanded upon to list the minimal features it would take to satisfy the use-case:
1. One live audio and video stream from lecture.
2. Ability to show slides simultaneously with video.
3. Ability to annotate and/or point to features on lecture slides during the lecture.
4. Interactive communication with remote students in the form of text-based chat.
Requirements were added  concerning the required software and  hardware. The first 
requirement is that the students attending the virtual lecture should not be required to have 
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
.NET PDF Document Viewing, Annotation, Conversion & Processing
Extract hyperlink inside PDF. PDF Write. Annotate & Comment. Add, insert PDF native annotations to PDF file. Edit, update, delete PDF annotations from PDF file.
accessible links in pdf; add hyperlink to pdf online
anything more than an internet-connected computer with a modern standards-compliant web 
browser, and the second: That everything the lecturer needs should be affordable, easily 
available in any part of the world and require only minimal technical understanding to set up 
and use. 
Finally, an important requirement was that the system be built with the knowledge that it 
should eventually be able to scale to a size such as has been accomplished with Wikipedia. 
The bandwidth required for video, coupled with the interactive elements of live teaching, 
make this a unique challenge. It would not be feasible to build such a system using a 
traditional, centrally administrated architecture as is used to support video sites like 
YouTube, since the cost of bandwidth alone would likely overwhelm the project beyond the 
ability for donations or even ads to support it. Rather, the system should be built with highly 
decentralized technologies where possible, in order to spread the cost of bandwidth, 
processing power and storage, across a large network of participating computers.
The second goal of the first phase was to develop a wiki-like site for uploading and viewing 
prerecorded video lectures. Other than a simple video upload and viewing site, of which 
there are many, the site should serve to organize large amounts of educational material by 
subject, using a system whereby users can ask to learn about a specific subject, and the site 
will inform the user of a suggested sequence of other topics or materials with which the user 
should be familiar before attempting to learn the subject at hand. If implemented on a large 
enough scale, this would enable the site to answer questions such as "I know subject X and I 
want to learn subject Y; How do I get from where I am to where I want to be?".   A 
requirement for this system was that suggestions given to the user regarding which 
additional subjects may depend on the subject currently viewed, must be specified in a 
collaborative manner by the users, as opposed to being centrally specified by a group of 
administrators. Inspiration for this system comes in part from Tutor-web [1], an existing web-
based educational platform that implements a dependency system.
OPEN STANDARDS AND OPEN LICENSING
A prime motivator for this project was the lack of good open source, open standards 
solutions for live teaching, so a requirement for the project was that all software must be free 
software (as specified by the free software definition [2]). The target license for the software 
is the GPLv3 or AGPLv3 Copyleft license, though some components that build on existing 
free software projects will have to keep to the licenses employed by those projects. As for 
open standards, the goal is to build something that does not employ any proprietary 
standards or technologies, and to use open standards where technically justifiable. During 
the course of development, it was deemed necessary to temporarily allow the use of 
proprietary technologies in certain cases where the open equivalents did not yet provide the 
necessary functionality.
The required license for all contributed content is Creative Commons Attribution Share-Alike 
3.0. This is the same license used by Wikipedia, and fits well with the spirit of both the Open 
Source [3] and Free Software definitions. This choice excludes some existing educational 
videos, such as the MIT OpenCourseWare material [4] with more restrictive licenses such as 
those Creative Commons licenses containing the "non-commercial" clause. Such exclusion 
will limit the amount of available material for the project, but the minimal restrictions will 
hopefully encourage more people to use the material, even in for-profit educational settings, 
and contribute their improvements and additions back to the project.
DESIGN – LIVE LECTURE PROJECT
Overview
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
The live lecture project can be divided into three high-level units:
1. The presentation software: For broadcasting a live lecture.
2. The server software: For facilitating communication between the presenter and students.
3. The student software: For participating in a live lecture.
These high-level units are further sub-divided as seen in the following diagram and explained 
in subsequent sections:
Presentation Software
The presentation software receives live audio and video from a video camera, encodes it to 
minimize the required bandwidth, and sends it to an audio/video server that forwards the 
streams to students. The presentation software allows the presenter to switch between a set 
of slides and annotate the slides using a pointing device. These slide change and annotion 
events are communicated to the students through a text-based communication server. The 
presentation allows two-way communication with the connected students in the form of a 
text-based chat through the same server.
The presentation software is a standalone GUI application. The optimal solution would be to 
implement it as a web-based application, but the limitations inherent in current web browsers 
would make some of the current and future goals difficult to implement, including input from 
DV and HDMI video cameras. To keep things simple for the first phase of development, a 
stand-alone application that runs on Ubuntu Linux was deemed sufficient. The application 
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
Illustration 1: Design of the live-lecture project. Node: Slide-changes and annotations 
are sent as text-based communication. The actual slides are uploaded as a pdf via the 
web-app.
was developed to be easily portable to the Windows and OS X operating systems; a goal for 
future versions. 
For slide annotation functionality, the presentation software accepts input from an input 
device, e.g. a mouse.
Server Software
The server software receives all of the data sent by the presenter software, video streams 
and text-based data, and sends this data to all connected students. The software also 
receives chat messages from students and sends it to the presenter software and to all other 
students. The server software also hosts the website for the student software including the 
database for the website.
The server software consists of at least four separate applications. 
1. The text-based communication server.
2. The audio/video communication serer.
3. The web server.
4. The database server.
The webserver and database server are fairly straightforward, together hosting the web-
based  student  software.  The  text-based-communication  server handles all text-based 
messages   sent   between   presenter   and/or   students.  These   messages   include   chat 
messages,  slide  change messages, and  slide  annotation messages    The text-based 
communication server also implements the concept of channels. The channel functions in the 
same way a chat channel does in most chat software. Each presentation has one associated 
channel, and the student and presenter software requests to join the channel when the user 
connects to a presentation. The text-based communication server forwards all messages 
sent with a specific channel as the recipient to every client that has joined the channel. The 
audio/video communication server allows the presenter to send a stream to the server that is 
then forwarded to the connected clients (student software) that request it.
Student Software
The student  software  is web-based.  It  receives  and  displays the  data  sent by the 
presentation software from the server: Video stream, slide-changes, slide annotations and 
chat messages. In addition, it allows the students to send chat messages to the server 
software, which is forwarded to the presenter and all connected students.
Modules
The live lecture system is designed to be highly modular in terms of functionality. Video, slide 
and chat functionality is implemented as three separate modules. Modularity in this context is 
independence of functionality that allows any one module to be removed or added, without 
affecting the functionality of any other module. Many modules will require code to be written 
for both student and presenter software, and in some cases even for the server software as 
well, so it is not required to be modular in the sense that it is a single piece of code. A future 
goal for the project is to encourage users and/or developers to write their own modules that 
facilitate the teaching of particular subjects and enables a variety of teaching styles. An 
example of such a module that is currently under development is the Piano module. The first 
version of the Piano module will accept midi input on the presenter side and displays the 
music notation for the played notes for the students as the teacher plays. Ideas for future 
modules include a screencasting module and a module for interfacing to smartpens such as 
the livescribe [5] allowing teachers to share hand written notes with students in real time. The 
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
modules are implemented such that the student software chooses which modules to enable, 
and the server software only sends and receives data for the modules enabled by the 
student software.
On Decentralization
It may seem odd to employ such a centralized server-based design, given the focus on a 
scalable peer-to-peer solution. This choice was made in part due to a lack of browser-based 
peer-to-peer support, but also as a way of limiting the scope of the project. Though peer-to-
peer in-browser streaming video solutions do exist, these technologies are not yet adapted to 
live streams where large delays are unwanted, and require third-party plug-ins that are either 
proprietary or not yet widely deployed [6]. It is also reasonable to assume that, even with full 
peer-to-peer support in a future version of the software, a fall-back option in the form of a 
traditional server-based approach will be needed to ensure a dependable and backwards 
compatible service for quite some time to come.  At the same time, Universal Primer 
developers have begun developing and testing a Java applet based peer-to-peer in-browser 
solution for the Universal Primer, which may in the future be able to provide peer-to-peer 
streaming video support.
IMPLEMENTATION – LIVE-LECTURE PROJECT
Server Software 
The server software facilitates communication between the student software and the 
presenter software. The server software consist of four applications:
1. Icecast2 / RTMPd: The streaming video server.
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
Illustration 2: Implementation of the live lecture design
2. Pushy: The Comet server.
3. RabbitMQ: AMQP Server.
4. Thin: The Ruby on Rails webserver.
5. MySQL: Database for Ruby on Rails.
The Thin [7] and MySQL [8] servers  are required to host the student software web app, 
which is discussed in further detail in the next section.
Streaming Video Server
Icecast2 [9] is an open source streaming media server capable of live video streams over 
HTTP suitable for the HTML5 video support built into modern browsers. As will be explained 
in the next section, the HTML5 video support proved problematic. For now, the Universal 
Primer uses Flash video. RTMPd is an open source streaming media server with support for 
the Real Time Messaging Protocol (RTMP) developed by Macromedia (now Adobe) and 
used for live streaming for Flash clients [10].
The RTMPd server is configured to receive a video stream from the presenter software over 
a TCP connection and send out the video over RTMP to all connected clients.
The video stream from the presenter software is in the FLash Video (FLV) [11] container 
format. The video format used is H.264 [12] and the audio format is MP3 [13]. The stream is 
sent as-is to clients, except for the change of protocol to RTMP. 
Pushy and AMQP
Pushy is a Comet server: A specialized HTTP server that facilitates two-way communication 
with JavaScript running in a web browser. Whereas a normal HTTP server uses a request-
response model, with all requests originating from the client, in a Comet server a connection 
is kept open and either server or client is free to initiate communication. Pushy is written in 
Ruby using the Rack framework [14]. It is based on the code from the "Pusher" Comet server 
developed by Marc-André Cournoyer [15]. 
The purpose of Pushy is to facilitate communication for the modules that rely on text-based 
data, including the chat module and the slide module. To accomplish this, it must solve two 
main problems. One problem is communicating with the student software and presenter 
software, and the other is implementing the concept of "channels" that ensures that data 
received from a student or presenter in a specific presentation is only forwarded to the other 
students and presenters connected to that presentation, similar to normal chat channels, e.g. 
Internet Relay Chat (IRC).
To facilitate communication with a wide range of web browsers, Pushy implements a set of 
different techniques, referred to as transports [16]. These transports are:
1. XHR Streaming: For Firefox, Safari and Chrome support.
2. HTMLFile: For Internet Explorer support.
3. Server-sent Events: Part of the HTML5 specification. Adds Opera support.
4. Server-sent Events draft: Needed to support older Opera browsers.
5. Long polling: For older browsers in general.
Pushy communication is based on simple JSON  (JavaScript Object Notation)  formatted 
messages. 
To implement the concept of channels, Pushy interfaces to a RabbitMQ process [17]. 
RabbitMQ is an open source application that supports the Advanced Message Queuing 
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
Protocol (AMQP) [18]. AMQP can be used to implement complex scenarios of message 
routing and queuing, which will likely be needed to meet demands for advanced features 
such as private messages and privilege levels, in future versions of the Universal Primer 
software. For now, the implementation is fairly straightforward. It is outside the scope of this 
report to explain the specifics of AMQP. Generally: Channels are implemented by using one 
named fanout exchange per channel, with each connected student or presenter creating a 
nameless queue and binding it to the fanout exchange. Sending messages to the channel is 
accomplished by publishing to the exchange, receiving messages by reading messages from 
the queue.
On Scalability
The technologies used, though based on the traditional client-server model, rather than the 
more scalable peer-to-peer mode, were chosen with some care to allow the system to scale. 
The MySQL server can be scaled using the MySQL cluster support [19], though it may be 
beneficial to move to a more scalable database solution such as the NoSQL database 
Apache CouchDB. RabbitMQ has good built-in clustering support, which should allow it to 
scale well, and RTMPd can be set up to forward video streams to other RTMPd nodes. The 
rest of the server software does clustering support in order to scale, as the relevant data is 
kept in sync between multiple different processes by the common database cluster (MySQL) 
and AMQP cluster (RabbitMQ).
Student Software
The student software used to view and participate in the presentation is fully web-based and 
consists of a server-side web application and a client-side JavaScript application.
The server-side web app was built using the Model-View-Control framework Ruby on Rails 
3.0 [20]. The web app uses a database back-end that can be a variety of SQL servers, such 
as the open source PostgreSQL server  [21]. The web app has four core pieces of 
functionality:
1. User login and new user sign-up.
2. Upload of PDF slides and conversion into sets of images.
3. Serving of the client-side HTML, CSS, JavaScript etc. that handles the actual 
presentation.
4. Exposing a web service to fetch the URL for specific slide images.
The implementation details of this web app are mostly trivial and will not be covered in this 
document, except for the pdf to image conversion and handling. The conversion is handled 
by the GraphicsMagick application [22]. This conversion is necessary because web browsers 
do not have PDF viewing capability built in. The images are generated once and saved to the 
server when the files are uploaded. The base path name for the images is saved to the 
database, allowing the web service to return the URL for the image of a specific slide on 
demand. 
The client-side application is mainly written in a combination of JavaScript, HTML and CSS. 
It is implemented as a single HTML web page, with the associated JavaScript, HTML and 
CSS residing in external files and with a minimal amount of in-line Ruby code to allow the 
server-side application to check if the user is logged in. 
As explained in the design section, there are three implemented modules: The video module, 
the slide module and the chat module. The implementation of these modules is explained in 
the following section.
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
GUI
The current GUI is exceedingly simple, and does not allow for presenter or students to resize 
or move the video or slide displays.
A new GUI is under development that will both give a more professional consistent look and 
feel, and allow more flexibility in resizing and moving the different modules. A screenshot of 
the work in progress:
This new GUI will be very task oriented. The design is as follows:
A minimalist interface displays video (one or more streams), slides, chat, interaction with 
lecture and other interface elements suitable for the subject.
The interface will be minimal and to some degree configurable - if there for example is a 
video stream and a slide viewer, one of these can be made central and big in the interface, 
while the other is smaller. It will be easy to switch these. It will also be possible to have 
several streams show up "big", if the screen real estate permits this.
The Video Module
It was attempted to implement the client-side of the video module using an HTML5 video tag, 
but after many tests with different configurations it was concluded that HTML5 video, though 
it works acceptably with prerecorded video files, is not ready to be used for live video 
streams. Observed problems included frequent and sometimes undetectable stalling, which 
is not acceptable in a live presentation situation. A HTML5 video solution will be re-evaluated 
when the technology is more mature.
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
Illustration 3: Elements of the new GUI
Instead, an Adobe Flash application was used for the video module. Though Flash is a 
proprietary technology, this was deemed a necessary temporary compromise. The open 
source FlowPlayer application [23] was used in this first version. FlowPlayer was deemed 
overly complicated for the purposes of this project, and a team-member began to develop a 
simple Adobe Flex based video player, that would be controllable by a javascript API equal to 
the HTML5 Video component, readying the application for future drop-in replacement of the 
Flash solution with an HTML5 solution. 
The Flash player connects to the server side RTMPd server using RTMP, and starts video 
playback as soon as the presenter starts sending video.
The Slide Module
The slide module was implemented as a simple HTML image tag showing the current slide. 
This has the drawback of disabling such features as copy-paste and zoom (an improved 
solution is discussed in the “Future Work” section). Changing to a different slide from the 
presentation is controlled by the presenter. The slide module receives a message, sent by 
the presenter software, telling it to change to a different slide, given by a page number, asks 
the server what the URL for the image associated with the slide is, and then changes the 
image source of the HTML image tag to the new image path, updating the displayed image. 
The communication with the presenter software is explained in one of the later sections. 
Annotations are received as a series of messages, each commanding the slide module to 
draw a line segment between to points given by two coordinates. An SVG component is 
overlaid on the image using the cross-browser vector-drawing library Raphael [24], and the 
specified line is drawn across the image for each received message. When a message is 
received to clear all lines, the equivalent Raphael API function is called and the SVG overlay 
is cleared. When the current slide is changed to a different page, the SVG overlay is also 
cleared. Annotations are not remembered when switching back to previous slides.
The Chat Module
The chat module GUI is implemented as an HTML unordered list, a textbox, and a button. 
The user first fills in the desired nickname on the chat and clicks the button; all subsequent 
clicks of the button send messages to the other chat participants for the current presentation. 
As chat messages are received, the chat module Javascript appends the messages to the 
list.
JavaScript Comet Library
To communicate the slide change, chat and slide annotation messages, a JavaScript library 
was developed, based on the Pusher code, to allow for robust cross-browser communication 
with the Pushy Comet server. This Comet JavaScript library includes support for the five 
different transports implemented for the Pushy server.
The Comet library includes an API for connecting/disconnecting from/to a channel on the 
Pushy server, including a parameter for, if, and how many times the library should attempt to 
auto-reconnect when a disconnect is detected. The following callbacks are implemented in 
the API:
1. on_connect: Called when connection succeeds.
2. on_connect_retry: When an auto-reconnect attempt is begun.
3. on_reconnect: When an auto-reconnect attempt succeeds.
4. on_disconnect: When an unexpected disconnect is detected.
5. on_receive: When a message is received.
Proceedings of the 7th International CDIO Conference, Technical University of Denmark, Copenhagen, June 20 - 23, 2011
Documents you may be interested
Documents you may be interested