Sophie: openvrml-doc-0.18.3-1mdv2010.0 i586

openvrml-doc-0.18.3-1mdv2010.0.i586.rpm

<!doctype html public "-//W3C//DTD HTML 4.01 Transitional//EN"
               "http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<title>OpenVRML: sdl_viewer.cpp</title>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<link rel="icon" href="../vrml-16">
<link rel="start" href="http://openvrml.org/index" title="OpenVRML Home">
<link rel="prev" href="http://openvrml.org/discussion" title="Discussion">
<link rel="contents" href="index" title="Documentation Main Page">
<link rel="index" href="functions" title="OpenVRML Compound Members">
<link rel="appendix" href="conformance" title="Conformance Test Results">
<style type="text/css">
@import url("tabs.css");
@import url("http://openvrml.org/openvrml.css");

table {
  width: 100%;
}

h2 {
  border-bottom-style: solid;
  border-bottom-width: 1px;
}

/*
 * Doxygen as of 1.5.4-20071217 uses the class "navpath" instead of "nav".
 * For now, we'll do both.
 */

div.nav,
div.navpath {
  background-color: transparent;
  text-align: left;
  margin-top: 1em;
  margin-bottom: 1em;
  border-color: black;
  border-left: none;
  border-right: none;
  padding-top: 0.5em;
  padding-bottom: 0.5em;
}

div.nav :link, div.nav :visited,
div.navpath :link, div.navpath :visited {
  border-width: 1px;
  border-style: solid;
  border-color: silver;
  padding: 2px;
}

div.nav :link:hover, div.nav :visited:hover,
div.navpath :link:hover, div.navpath :visited:hover {
  border-style: outset;
  border-color: gray;
}

div.nav :active,
div.navpath :active {
  border-style: inset;
  border-color: gray;
}

.body td {
  background-color: transparent;
}

.el {
  text-decoration: inherit;
  font-weight: inherit
}
.elRef {
  font-weight: inherit
}
.code:link, .code:visited {
  text-decoration: inherit;
  font-weight: inherit;
  color: inherit;
}
.codeRef:link {
  font-weight: normal;
  color: inherit;
}
:visited {
  color: silver;
}
:link:hover {
  color: inherit;
  text-decoration: inherit;
  background-color: transparent;
}

h1 {
  line-height: 1.2em;
}

td.memItemLeft, td.memItemRight,
td.memTemplParams, td.memTemplItemLeft, td.memTemplItemRight,
.memtemplate, .memname td {
  font-family: Consolas, "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Lucida Console", LucidaTypewriter, monospace;
}

td.memItemLeft, td.memItemRight, td.mdescLeft, td.mdescRight {
  background-color: rgb(95%, 95%, 95%);
  border-color: rgb(65%, 65%, 65%);
  border-width: 1px;
  font-size: smaller;
}

.memItemLeft {
  margin-top: 0.5em;
  border-top-style: solid;
}
.mdescLeft {
  border-bottom-style: solid;
}
.memItemRight {
  border-top-style: solid;
  margin-top: 0.5em;
}
.mdescRight {
  border-bottom-style: solid;
}

.mdescRight {
  font-style: italic;
}

.mdTable {
  background-color: rgb(95%, 95%, 95%);
}

.memproto td code {
  font-family: inherit;
  font-style: italic;
}

td.pass {
  background-color: rgb(50%, 100%, 50%);
}

td.fail {
  background-color: rgb(100%, 50%, 50%);
}

td.invalid {
  background-color: rgb(75%, 75%, 75%);
}

.memitem {
  padding: 0;
}

.memitem table {
  width: auto;
}

.memproto, .memdoc {
  border-width: 1px;
  border-color: rgb(65%, 65%, 65%);
}

.memproto {
  background-color: rgb(90%, 90%, 90%);
  font-weight: inherit;
  font-size: smaller;
  border-top-style: solid;
  border-left-style: solid;
  border-right-style: solid;
  -webkit-border-top-left-radius: 0.6em;
  -webkit-border-top-right-radius: 0.6em;
  -moz-border-radius-topleft: 0.6em;
  -moz-border-radius-topright: 0.6em;
}

.memdoc {
  background-color: rgb(95%, 95%, 95%);
  padding: 2px 5px;
  border-style: solid;
  -webkit-border-bottom-left-radius: 0.6em;
  -webkit-border-bottom-right-radius: 0.6em;
  -moz-border-radius-bottomleft: 0.6em;
  -moz-border-radius-bottomright: 0.6em;
}

.memname {
  font-weight: inherit;
}

div.tabs {
  background-image: url("tab_b-openvrml.png");
}

div.tabs span {
  background-image: url("tab_l-openvrml.png");
}

div.tabs a {
  background-image: url("tab_r-openvrml.png");
  border-bottom: 1px solid #a5a5a5;
}

div.tabs a:link, div.tabs a:visited, div.tabs a:active, div.tabs a:hover {
  color: black;
}

table {
  border-collapse: collapse;
  border-spacing: 0;
}

.note {
  border: 1px solid rgb(65%, 65%, 65%);
  background-color: rgb(95%, 95%, 95%);
  margin-left: 10%;
  margin-right: 10%;
}
</style>
</head>
<body>
<table class="sitenav">
  <tr>
    <th><a href="http://openvrml.org/index" title="Home">Home</a></th>
    <th><a href="http://openvrml.org/download" title="Download">Download</a></th>
    <th><a href="http://openvrml.org/screenshots/index" title="Screen shots">Screen shots</a></th>
    <th><a href="http://openvrml.org/discussion" title="Mailing lists and IRC">Discussion</a></th>
    <th>Documentation</th>
  </tr>
</table>
<div class="body">
<!-- Generated by Doxygen 1.5.8 -->
<div class="navigation" id="top">
  <div class="tabs">
    <ul>
      <li><a href="index.html"><span>Main&nbsp;Page</span></a></li>
      <li><a href="pages.html"><span>Related&nbsp;Pages</span></a></li>
      <li><a href="namespaces.html"><span>Namespaces</span></a></li>
      <li><a href="annotated.html"><span>Classes</span></a></li>
      <li><a href="files.html"><span>Files</span></a></li>
      <li><a href="examples.html"><span>Examples</span></a></li>
    </ul>
  </div>
</div>
<div class="contents">
<h1>sdl_viewer.cpp</h1>Basic example using <code><a class="el" href="classopenvrml_1_1browser.html" title="Encapsulates a VRML browser.">openvrml::browser</a></code>.<p>
<div class="fragment"><pre class="fragment"><span class="comment">// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 78 -*-</span>
<span class="comment">//</span>
<span class="comment">// sdl-viewer</span>
<span class="comment">//</span>
<span class="comment">// Copyright 2003, 2004, 2005, 2006, 2007  Braden McDaniel</span>
<span class="comment">//</span>
<span class="comment">// This program is free software; you can redistribute it and/or modify it</span>
<span class="comment">// under the terms of the GNU General Public License as published by the Free</span>
<span class="comment">// Software Foundation; either version 3 of the License, or (at your option)</span>
<span class="comment">// any later version.</span>
<span class="comment">//</span>
<span class="comment">// This program is distributed in the hope that it will be useful, but WITHOUT</span>
<span class="comment">// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or</span>
<span class="comment">// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for</span>
<span class="comment">// more details.</span>
<span class="comment">//</span>
<span class="comment">// You should have received a copy of the GNU General Public License along</span>
<span class="comment">// with this library; if not, see &lt;http://www.gnu.org/licenses/&gt;.</span>
<span class="comment">//</span>

<span class="preprocessor"># ifdef HAVE_CONFIG_H</span>
<span class="preprocessor"></span><span class="preprocessor">#   include &lt;config.h&gt;</span>
<span class="preprocessor"># endif</span>
<span class="preprocessor"></span>
<span class="preprocessor"># include &lt;iostream&gt;</span>
<span class="preprocessor"># include &lt;fstream&gt;</span>
<span class="preprocessor"># include &lt;boost/algorithm/string/predicate.hpp&gt;</span>
<span class="preprocessor"># include &lt;boost/utility.hpp&gt;</span>
<span class="preprocessor"># include &lt;SDL.h&gt;</span>
<span class="preprocessor"># include &lt;<a class="code" href="browser_8h.html" title="Classes that manage the scene.">openvrml/browser.h</a>&gt;</span>
<span class="preprocessor"># include &lt;<a class="code" href="gl_2openvrml_2gl_2viewer_8h.html" title="Definition of openvrml::gl::viewer.">openvrml/gl/viewer.h</a>&gt;</span>
<span class="preprocessor"># ifdef _WIN32</span>
<span class="preprocessor"></span><span class="preprocessor">#   include &lt;windows.h&gt;</span>
<span class="preprocessor"># endif</span>
<span class="preprocessor"></span>
<span class="keyword">extern</span> <span class="stringliteral">"C"</span> Uint32 update_timer_callback(Uint32 interval, <span class="keywordtype">void</span> * param);

<span class="keyword">namespace </span>{

    <span class="keyword">class </span>resource_fetcher : <span class="keyword">public</span> openvrml::resource_fetcher {
    <span class="keyword">private</span>:
        <span class="keyword">virtual</span> std::auto_ptr&lt;openvrml::resource_istream&gt;
        do_get_resource(<span class="keyword">const</span> std::string &amp; uri);
    };


    <span class="keyword">class </span>sdl_error : <span class="keyword">public</span> std::runtime_error {
    <span class="keyword">public</span>:
        <span class="keyword">explicit</span> sdl_error(<span class="keyword">const</span> std::string &amp; message);
        <span class="keyword">virtual</span> ~sdl_error() throw ();
    };

    class sdl_viewer : public openvrml::gl::viewer {
        <span class="keyword">friend</span> Uint32 update_timer_callback(Uint32 interval, <span class="keywordtype">void</span> * param);

        <span class="keyword">static</span> <span class="keyword">const</span> Uint32 video_mode_flags;

        SDL_TimerID update_timer_id;
        <span class="keywordtype">bool</span> mouse_button_down;

    <span class="keyword">public</span>:
        <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">int</span> redraw_event_code = 1;
        <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">int</span> update_event_code = 2;

        <span class="keyword">explicit</span> sdl_viewer(<span class="keyword">const</span> std::string &amp; title) <span class="keywordflow">throw</span> (sdl_error);
        <span class="keyword">virtual</span> ~sdl_viewer() throw ();

        <span class="keywordtype">void</span> run();

        <span class="comment">//</span>
        <span class="comment">// Window system specific methods</span>
        <span class="comment">//</span>
        virtual <span class="keywordtype">void</span> do_post_redraw();
        virtual <span class="keywordtype">void</span> do_set_cursor(cursor_style c);
        virtual <span class="keywordtype">void</span> do_swap_buffers();
        virtual <span class="keywordtype">void</span> do_set_timer(<span class="keywordtype">double</span>);
    };
}

<span class="keywordtype">int</span> main(<span class="keywordtype">int</span> argc, <span class="keywordtype">char</span> * argv[])
{
    <span class="keyword">using</span> std::cerr;
    <span class="keyword">using</span> std::endl;

<span class="preprocessor"># ifdef _WIN32</span>
<span class="preprocessor"></span>    AllocConsole();
    FILE * out;
    freopen_s(&amp;out, <span class="stringliteral">"conout$"</span>, <span class="stringliteral">"w"</span>, stdout);
    freopen_s(&amp;out, <span class="stringliteral">"conout$"</span>, <span class="stringliteral">"w"</span>, stderr);
<span class="preprocessor"># endif</span>
<span class="preprocessor"></span>
    <span class="keywordflow">if</span> (argc &lt; 2) {
        cerr &lt;&lt; <span class="stringliteral">"Usage: "</span> &lt;&lt; argv[0] &lt;&lt; <span class="stringliteral">" URL"</span> &lt;&lt; endl;
        <span class="keywordflow">return</span> EXIT_FAILURE;
    }

    <span class="keywordflow">try</span> {
        <span class="keyword">using</span> std::string;
        <span class="keyword">using</span> std::vector;

        <span class="keyword">const</span> <span class="keywordtype">string</span> url = argv[1];

        sdl_viewer v(url);
        resource_fetcher fetcher;
        <a name="_a0"></a><a class="code" href="classopenvrml_1_1browser.html" title="Encapsulates a VRML browser.">openvrml::browser</a> b(fetcher, std::cout, std::cerr);
        b.viewer(&amp;v);

        vector&lt;string&gt; uri(1, url);
        vector&lt;string&gt; parameter;
        b.load_url(uri, parameter);

        v.run();
    } <span class="keywordflow">catch</span> (std::exception &amp; ex) {
        cerr &lt;&lt; ex.what() &lt;&lt; endl;
        <span class="keywordflow">return</span> EXIT_FAILURE;
    }

<span class="preprocessor"># ifdef _WIN32</span>
<span class="preprocessor"></span>    fclose(out);
    FreeConsole();
<span class="preprocessor"># endif</span>
<span class="preprocessor"></span>
    <span class="keywordflow">return</span> EXIT_SUCCESS;
}

<span class="keyword">namespace </span>{

    std::auto_ptr&lt;openvrml::resource_istream&gt;
    resource_fetcher::do_get_resource(<span class="keyword">const</span> std::string &amp; uri)
    {
        <span class="keyword">using</span> std::auto_ptr;
        <span class="keyword">using</span> std::invalid_argument;
        <span class="keyword">using</span> std::string;
        <span class="keyword">using</span> <a name="_a1"></a><a class="code" href="classopenvrml_1_1resource__istream.html" title="An abstract input stream for network resources.">openvrml::resource_istream</a>;

        <span class="keyword">class </span>file_resource_istream : <span class="keyword">public</span> resource_istream {
            std::string url_;
            std::filebuf buf_;

        <span class="keyword">public</span>:
            <span class="keyword">explicit</span> file_resource_istream(<span class="keyword">const</span> std::string &amp; path):
                resource_istream(&amp;this-&gt;buf_)
            {
                <span class="keywordflow">if</span> (!this-&gt;buf_.open(path.c_str(),
                                     ios_base::in | ios_base::binary)) {
                    this-&gt;setstate(ios_base::badbit);
                }
            }

            <span class="keywordtype">void</span> url(<span class="keyword">const</span> std::string &amp; str) <span class="keywordflow">throw</span> (std::bad_alloc)
            {
                this-&gt;url_ = str;
            }

        <span class="keyword">private</span>:
            <span class="keyword">virtual</span> <span class="keyword">const</span> std::string do_url() <span class="keyword">const</span> throw ()
            {
                <span class="keywordflow">return</span> this-&gt;url_;
            }

            <span class="keyword">virtual</span> <span class="keyword">const</span> std::string do_type() <span class="keyword">const</span> throw ()
            {
                <span class="comment">//</span>
                <span class="comment">// A real application should use OS facilities for this.  This</span>
                <span class="comment">// is a crude hack because sdl-viewer uses std::filebuf in</span>
                <span class="comment">// order to remain simple and portable.</span>
                <span class="comment">//</span>
                <span class="keyword">using</span> std::find;
                <span class="keyword">using</span> std::string;
                <span class="keyword">using</span> boost::algorithm::iequals;
                <span class="keyword">using</span> boost::next;
                <span class="keywordtype">string</span> media_type = <span class="stringliteral">"application/octet-stream"</span>;
                <span class="keyword">const</span> string::const_reverse_iterator dot_pos =
                    find(this-&gt;url_.rbegin(), this-&gt;url_.rend(), <span class="charliteral">'.'</span>);
                <span class="keywordflow">if</span> (dot_pos == this-&gt;url_.rend()
                    || next(dot_pos.base()) == this-&gt;url_.end()) {
                    <span class="keywordflow">return</span> media_type;
                }
                <span class="keyword">const</span> string::const_iterator hash_pos =
                    find(next(dot_pos.base()), this-&gt;url_.end(), <span class="charliteral">'#'</span>);
                <span class="keyword">const</span> <span class="keywordtype">string</span> ext(dot_pos.base(), hash_pos);
                <span class="keywordflow">if</span> (iequals(ext, <span class="stringliteral">"wrl"</span>)) {
                    media_type = <a name="a2"></a><a class="code" href="namespaceopenvrml.html#b271737a62b4e27e3272775a00838c3d" title="VRML MIME media type.">openvrml::vrml_media_type</a>;
                } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (iequals(ext, <span class="stringliteral">"x3dv"</span>)) {
                    media_type = <a name="a3"></a><a class="code" href="namespaceopenvrml.html#acc18960fcb687d52d2a156a7dab4775" title="X3D VRML MIME media type.">openvrml::x3d_vrml_media_type</a>;
                } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (iequals(ext, <span class="stringliteral">"png"</span>)) {
                    media_type = <span class="stringliteral">"image/png"</span>;
                } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (iequals(ext, <span class="stringliteral">"jpg"</span>) || iequals(ext, <span class="stringliteral">"jpeg"</span>)) {
                    media_type = <span class="stringliteral">"image/jpeg"</span>;
                } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (iequals(ext, <span class="stringliteral">"class"</span>)) {
                    media_type = <span class="stringliteral">"application/java"</span>;
                } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (iequals(ext, <span class="stringliteral">"js"</span>)) {
                    media_type = <span class="stringliteral">"application/javascript"</span>;
                }
                <span class="keywordflow">return</span> media_type;
            }

            <span class="keyword">virtual</span> <span class="keywordtype">bool</span> do_data_available() <span class="keyword">const</span> throw ()
            {
                <span class="keywordflow">return</span> !!(*this);
            }
        };

        <span class="keyword">const</span> <span class="keywordtype">string</span> scheme = uri.substr(0, uri.find_first_of(<span class="charliteral">':'</span>));
        <span class="keywordflow">if</span> (scheme != <span class="stringliteral">"file"</span>) {
            <span class="keywordflow">throw</span> invalid_argument(<span class="charliteral">'\"'</span> + scheme + <span class="stringliteral">"\" URI scheme not "</span>
                                   <span class="stringliteral">"supported"</span>);
        }

        <span class="comment">//</span>
        <span class="comment">// file://</span>
        <span class="comment">//        ^</span>
        <span class="comment">// 01234567</span>
        <span class="keyword">static</span> <span class="keyword">const</span> string::size_type authority_start_index = 7;

        <span class="comment">//</span>
        <span class="comment">// On Windows we want to start at the drive letter, which is after the</span>
        <span class="comment">// first slash in the path.</span>
        <span class="comment">//</span>
        <span class="comment">// We ignore the content of the authority; a smarter implementation</span>
        <span class="comment">// should confirm that it is localhost, the machine name, or zero</span>
        <span class="comment">// length.</span>
        <span class="comment">//</span>
        <span class="comment">// We also don't do any translation of URI-encoded characters here.</span>
        <span class="comment">// That means that things like paths with spaces in them aren't going</span>
        <span class="comment">// to work.  Oh, well.</span>
        <span class="comment">//</span>
        string::size_type path_start_index =
<span class="preprocessor"># ifdef _WIN32</span>
<span class="preprocessor"></span>            uri.find_first_of(<span class="charliteral">'/'</span>, authority_start_index) + 1;
<span class="preprocessor"># else</span>
<span class="preprocessor"></span>            uri.find_first_of(<span class="charliteral">'/'</span>, authority_start_index);
<span class="preprocessor"># endif</span>
<span class="preprocessor"></span>        <span class="keywordtype">string</span> path = uri.substr(path_start_index);

        auto_ptr&lt;resource_istream&gt; in(<span class="keyword">new</span> file_resource_istream(path));
        <span class="keyword">static_cast&lt;</span>file_resource_istream *<span class="keyword">&gt;</span>(in.get())-&gt;url(uri);

        <span class="keywordflow">return</span> in;
    }

    sdl_error::sdl_error(<span class="keyword">const</span> std::string &amp; message):
        std::runtime_error(message)
    {}

    sdl_error::~sdl_error() throw ()
    {}

    <span class="keyword">const</span> Uint32 sdl_viewer::video_mode_flags(SDL_OPENGL | SDL_RESIZABLE);

    sdl_viewer::sdl_viewer(<span class="keyword">const</span> std::string &amp; title) <span class="keywordflow">throw</span> (sdl_error):
        update_timer_id(0),
        mouse_button_down(<span class="keyword">false</span>)
    {
        <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">size_t</span> initial_width = 640;
        <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">size_t</span> initial_height = 480;

        <span class="keywordflow">if</span> (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO) &lt; 0) {
            <span class="keywordflow">throw</span> sdl_error(SDL_GetError());
        }
        <span class="keywordflow">if</span> (!SDL_SetVideoMode(initial_width,
                              initial_height,
                              0,
                              sdl_viewer::video_mode_flags)) {
            <span class="keywordflow">throw</span> sdl_error(SDL_GetError());
        }
        this-&gt;resize(initial_width, initial_height);

        <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span> * <span class="keyword">const</span> icon = 0;
        SDL_WM_SetCaption(title.c_str(), icon);
    }

    sdl_viewer::~sdl_viewer() throw ()
    {
        SDL_Quit();
    }

    <span class="keywordtype">void</span> sdl_viewer::run()
    {
        this-&gt;update();
        <span class="keywordtype">bool</span> done = <span class="keyword">false</span>;
        <span class="keywordtype">bool</span> need_update = <span class="keyword">false</span>;
        <span class="keywordtype">bool</span> need_redraw = <span class="keyword">false</span>;
        <span class="keywordflow">do</span> {
            SDL_Event <span class="keyword">event</span> = {};
            sdl_viewer::event_info viewer_event_info = {};
            <span class="keywordflow">while</span> (SDL_PollEvent(&amp;event)) {
                <span class="keywordflow">switch</span> (event.type) {
                <span class="keywordflow">case</span> SDL_VIDEOEXPOSE:
                    this-&gt;post_redraw();
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">case</span> SDL_VIDEORESIZE:
                    SDL_SetVideoMode(event.resize.w,
                                     event.resize.h,
                                     0,
                                     sdl_viewer::video_mode_flags);
                    this-&gt;resize(event.resize.w, event.resize.h);
                    this-&gt;post_redraw();
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">case</span> SDL_KEYDOWN:
                    viewer_event_info.event = sdl_viewer::event_key_down;
                    <span class="keywordflow">switch</span> (event.key.keysym.sym) {
                    <span class="keywordflow">case</span> SDLK_HOME:
                        viewer_event_info.what = sdl_viewer::key_home;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> SDLK_LEFT:
                        viewer_event_info.what = sdl_viewer::key_left;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> SDLK_UP:
                        viewer_event_info.what = sdl_viewer::key_up;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> SDLK_RIGHT:
                        viewer_event_info.what = sdl_viewer::key_right;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> SDLK_DOWN:
                        viewer_event_info.what = sdl_viewer::key_down;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> SDLK_PAGEDOWN:
                        viewer_event_info.what = sdl_viewer::key_page_down;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> SDLK_PAGEUP:
                        viewer_event_info.what = sdl_viewer::key_page_up;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">default</span>:
                        <span class="keywordflow">break</span>;
                    }
                    this-&gt;input(&amp;viewer_event_info);
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">case</span> SDL_MOUSEBUTTONDOWN: <span class="keywordflow">case</span> SDL_MOUSEBUTTONUP:
                    viewer_event_info.event = <span class="keyword">event</span>.button.state == SDL_PRESSED
                                            ? sdl_viewer::event_mouse_click
                                            : sdl_viewer::event_mouse_release;
                    viewer_event_info.what = <span class="keyword">event</span>.button.button - 1;
                    viewer_event_info.x = <span class="keyword">event</span>.button.x;
                    viewer_event_info.y = <span class="keyword">event</span>.button.y;
                    this-&gt;input(&amp;viewer_event_info);
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">case</span> SDL_MOUSEMOTION:
                    <span class="keywordflow">if</span> (!event.motion.state) {
                        viewer_event_info.event = sdl_viewer::event_mouse_move;
                        viewer_event_info.x = <span class="keyword">event</span>.motion.x;
                        viewer_event_info.y = <span class="keyword">event</span>.motion.y;
                        this-&gt;input(&amp;viewer_event_info);
                    } <span class="keywordflow">else</span> {
                        <span class="keywordflow">for</span> (Uint8 button = SDL_BUTTON_LEFT;
                             button &lt; 4;
                             ++button) {
                            <span class="keywordflow">if</span> (event.motion.state &amp; SDL_BUTTON(button)) {
                                viewer_event_info.event =
                                    sdl_viewer::event_mouse_drag;
                                viewer_event_info.what = button - 1;
                                viewer_event_info.x = <span class="keyword">event</span>.motion.x;
                                viewer_event_info.y = <span class="keyword">event</span>.motion.y;
                                this-&gt;input(&amp;viewer_event_info);
                            }
                        }
                    }
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">case</span> SDL_QUIT:
                    done = <span class="keyword">true</span>;
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">case</span> SDL_USEREVENT:
                    <span class="keywordflow">switch</span> (event.user.code) {
                    <span class="keywordflow">case</span> redraw_event_code:
                        need_redraw = <span class="keyword">true</span>;
                        <span class="keywordflow">break</span>;
                    <span class="keywordflow">case</span> update_event_code:
                        need_update = <span class="keyword">true</span>;
                        <span class="keywordflow">break</span>;
                    }
                    <span class="keywordflow">break</span>;
                <span class="keywordflow">default</span>:
                    <span class="keywordflow">break</span>;
                }
            }
            <span class="keywordflow">if</span> (need_update) {
                this-&gt;update();
                need_update = <span class="keyword">false</span>;
            }
            <span class="keywordflow">if</span> (need_redraw) {
                this-&gt;redraw();
                need_redraw = <span class="keyword">false</span>;
            }
        } <span class="keywordflow">while</span> (!done);
    }

    <span class="keywordtype">void</span> sdl_viewer::do_post_redraw()
    {
        SDL_Event redraw_event;
        redraw_event.type = SDL_USEREVENT;
        redraw_event.user.code = sdl_viewer::redraw_event_code;
        redraw_event.user.data1 = 0;
        redraw_event.user.data2 = 0;
        SDL_PushEvent(&amp;redraw_event);
    }

    <span class="keywordtype">void</span> sdl_viewer::do_set_cursor(cursor_style)
    {}

    <span class="keywordtype">void</span> sdl_viewer::do_swap_buffers()
    {
        SDL_GL_SwapBuffers();
    }

    Uint32 update_timer_callback(Uint32 <span class="comment">/* interval */</span>, <span class="keywordtype">void</span> * <span class="keyword">const</span> param)
    {
        sdl_viewer &amp; v = *<span class="keyword">static_cast&lt;</span>sdl_viewer *<span class="keyword">&gt;</span>(param);
        SDL_RemoveTimer(v.update_timer_id);
        v.update_timer_id = 0;
        SDL_Event update_event;
        update_event.type = SDL_USEREVENT;
        update_event.user.code = sdl_viewer::update_event_code;
        update_event.user.data1 = 0;
        update_event.user.data2 = 0;
        SDL_PushEvent(&amp;update_event);
        <span class="keywordflow">return</span> 0;
    }

    <span class="keywordtype">void</span> sdl_viewer::do_set_timer(<span class="keyword">const</span> <span class="keywordtype">double</span> t)
    {
        <span class="keywordflow">if</span> (!this-&gt;update_timer_id) {
            <span class="keyword">const</span> Uint32 interval = Uint32(1000.0 * t + 20); <span class="comment">// milliseconds.</span>
            this-&gt;update_timer_id =
                SDL_AddTimer(interval, update_timer_callback, <span class="keyword">this</span>);
        }
    }
}
</pre></div> </div>
</div>
<address class="footer"><span class="images"><a href="http://web3d.org/x3d/"><img src="x3d-white-on-black.png" width="43" height="32" border="0" alt="X3D"></a><a href="http://opengl.org"><img src="OGL_sm_wht.png" width="68" height="32" border="0" alt="OpenGL"></a><a href="http://sourceforge.net/projects/openvrml"><img src="http://sourceforge.net/sflogo.php?group_id=7151&amp;type=11" width="120" height="30" border="0" alt="SourceForge.net"></a></span><a href="https://sourceforge.net/apps/trac/openvrml/newticket">Report error</a><br>Generated Thu Aug 13 02:49:09 2009 by Doxygen 1.5.8</address>
<script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
<script type="text/javascript">_uacct = "UA-446379-2"; urchinTracker();</script>
<!-- Piwik -->
<script type="text/javascript">
var pkBaseURL = (("https:" == document.location.protocol) ? "https://sourceforge.net/apps/piwik/openvrml/" : "http://sourceforge.net/apps/piwik/openvrml/");
document.write(unescape("%3Cscript src='" + pkBaseURL + "piwik.js' type='text/javascript'%3E%3C/script%3E"));
</script><script type="text/javascript">
piwik_action_name = '';
piwik_idsite = 1;
piwik_url = pkBaseURL + "piwik.php";
piwik_log(piwik_action_name, piwik_idsite, piwik_url);
</script>
<object><noscript><p><img src="http://sourceforge.net/apps/piwik/openvrml/piwik.php?idsite=1" alt="piwik"/></p></noscript></object>
<!-- End Piwik Tag -->
</body>
</html>