generic-poky/meta-extras/packages/helix/helix-libs/add-clutter.patch

Index: helix-libs/clientapps/clutter/LICENSE.txt
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/LICENSE.txt	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,30 @@
+ Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.  
+        
+ The contents of this directory, and (except where otherwise
+ indicated) the directories included within this directory, are
+ subject to the current version of the RealNetworks Public Source
+ License (the "RPSL") available at RPSL.txt in this directory, unless
+ you have licensed the directory under the current version of the
+ RealNetworks Community Source License (the "RCSL") available at
+ RCSL.txt in this directory, in which case the RCSL will apply. You
+ may also obtain the license terms directly from RealNetworks.  You
+ may not use the files in this directory except in compliance with the
+ RPSL or, if you have a valid RCSL with RealNetworks applicable to
+ this directory, the RCSL.  Please see the applicable RPSL or RCSL for
+ the rights, obligations and limitations governing use of the contents
+ of the directory.
+ 
+ This directory is part of the Helix DNA Technology. RealNetworks is
+ the developer of the Original Code and owns the copyrights in the
+ portions it created.
+   
+ This directory, and the directories included with this directory, are
+ distributed and made available on an 'AS IS' basis, WITHOUT WARRANTY
+ OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY
+ DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+ QUIET ENJOYMENT OR NON-INFRINGEMENT.
+  
+ Technology Compatibility Kit Test Suite(s) Location:  
+    http://www.helixcommunity.org/content/tck  
+
Index: helix-libs/clientapps/clutter/RCSL.txt
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/RCSL.txt	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,948 @@
+The RCSL is made up of a base agreement and a few Attachments.
+
+For Research and Development use, you agree to the terms of the
+RCSL R&D License (base RCSL and Attachments A, B, and C) 
+
+For Commercial Use (either distribution or internal commercial
+deployment) of the Helix DNA with or without support for RealNetworks'
+RealAudio and RealVideo Add-on Technology, you agree to the
+terms of the same RCSL R&D license
+and execute one or more additional Commercial Use License attachments
+<see http://www.helixcommunity.org/content/rcsl-attachments>.
+
+------------------------------------------------------------------------
+
+
+    REALNETWORKS COMMUNITY SOURCE LICENSE
+
+Version 1.2 (Rev. Date: January 22, 2003).
+
+
+  RECITALS
+
+Original Contributor has developed Specifications, Source Code
+implementations and Executables of certain Technology; and
+
+Original Contributor desires to license the Technology to a large
+community to facilitate research, innovation and product development
+while maintaining compatibility of such products with the Technology as
+delivered by Original Contributor; and
+
+Original Contributor desires to license certain Trademarks for the
+purpose of branding products that are compatible with the relevant
+Technology delivered by Original Contributor; and
+
+You desire to license the Technology and possibly certain Trademarks
+from Original Contributor on the terms and conditions specified in this
+License.
+
+In consideration for the mutual covenants contained herein, You and
+Original Contributor agree as follows:
+
+
+  AGREEMENT
+
+*1. Introduction.*
+
+The RealNetworks Community Source License ("RCSL") and effective
+attachments ("License") may include five distinct licenses:
+
+i) Research Use license -- License plus Attachments A, B and C only.
+
+ii) Commercial Use and Trademark License, which may be for Internal
+Deployment Use or external distribution, or both -- License plus
+Attachments A, B, C, and D.
+
+iii) Technology Compatibility Kit (TCK) license -- Attachment C.
+
+iv) Add-On Technology License (Executable) Commercial Use License
+-Attachment F.
+
+v) Add-On Technology Source Code Porting and Optimization
+License-Attachment G.
+
+The Research Use license is effective when You click and accept this
+License. The TCK is effective when You click and accept this License,
+unless otherwise specified in the TCK attachments. The Commercial Use
+and Trademark, Add-On Technology License, and the Add-On Technology
+Source Code Porting and Optimization licenses must each be signed by You
+and Original Contributor to become effective. Once effective, these
+licenses and the associated requirements and responsibilities are
+cumulative. Capitalized terms used in this License are defined in the
+Glossary.
+
+*2. License Grants.*
+
+2.1 Original Contributor Grant.
+
+Subject to Your compliance with Sections 3, 8.10 and Attachment A of
+this License, Original Contributor grants to You a worldwide,
+royalty-free, non-exclusive license, to the extent of Original
+Contributor's Intellectual Property Rights covering the Original Code,
+Upgraded Code and Specifications, to do the following:
+
+(a) Research Use License:
+
+(i) use, reproduce and modify the Original Code, Upgraded Code and
+Specifications to create Modifications and Reformatted Specifications
+for Research Use by You;
+
+(ii) publish and display Original Code, Upgraded Code and Specifications
+with, or as part of Modifications, as permitted under Section 3.1(b) below;
+
+(iii) reproduce and distribute copies of Original Code and Upgraded Code
+to Licensees and students for Research Use by You;
+
+(iv) compile, reproduce and distribute Original Code and Upgraded Code
+in Executable form, and Reformatted Specifications to anyone for
+Research Use by You.
+
+(b) Other than the licenses expressly granted in this License, Original
+Contributor retains all right, title, and interest in Original Code and
+Upgraded Code and Specifications.
+
+2.2 Your Grants.
+
+(a) To Other Licensees. You hereby grant to each Licensee a license to
+Your Error Corrections and Shared Modifications, of the same scope and
+extent as Original Contributor's licenses under Section 2.1 a) above
+relative to Research Use and Attachment D relative to Commercial Use.
+
+(b) To Original Contributor. You hereby grant to Original Contributor a
+worldwide, royalty-free, non-exclusive, perpetual and irrevocable
+license, to the extent of Your Intellectual Property Rights covering
+Your Error Corrections, Shared Modifications and Reformatted
+Specifications, to use, reproduce, modify, display and distribute Your
+Error Corrections, Shared Modifications and Reformatted Specifications,
+in any form, including the right to sublicense such rights through
+multiple tiers of distribution.
+
+(c) Other than the licenses expressly granted in Sections 2.2(a) and (b)
+above, and the restrictions set forth in Section 3.1(d)(iv) below, You
+retain all right, title, and interest in Your Error Corrections, Shared
+Modifications and Reformatted Specifications.
+
+2.3 Contributor Modifications.
+
+You may use, reproduce, modify, display and distribute Contributor Error
+Corrections, Shared Modifications and Reformatted Specifications,
+obtained by You under this License, to the same scope and extent as with
+Original Code, Upgraded Code and Specifications.
+
+2.4 Subcontracting.
+
+You may deliver the Source Code of Covered Code to other Licensees
+having at least a Research Use license, for the sole purpose of
+furnishing development services to You in connection with Your rights
+granted in this License. All such Licensees must execute appropriate
+documents with respect to such work consistent with the terms of this
+License, and acknowledging their work-made-for-hire status or assigning
+exclusive right to the work product and associated Intellectual Property
+Rights to You.
+
+*3. Requirements and Responsibilities*.
+
+3.1 Research Use License.
+
+As a condition of exercising the rights granted under Section 2.1(a)
+above, You agree to comply with the following:
+
+(a) Your Contribution to the Community. All Error Corrections and Shared
+Modifications which You create or contribute to are automatically
+subject to the licenses granted under Section 2.2 above. You are
+encouraged to license all of Your other Modifications under Section 2.2
+as Shared Modifications, but are not required to do so. You agree to
+notify Original Contributor of any errors in the Specification.
+
+(b) Source Code Availability. You agree to provide all Your Error
+Corrections to Original Contributor as soon as reasonably practicable
+and, in any event, prior to Internal Deployment Use or Commercial Use,
+if applicable. Original Contributor may, at its discretion, post Source
+Code for Your Error Corrections and Shared Modifications on the
+Community Webserver. You may also post Error Corrections and Shared
+Modifications on a web-server of Your choice; provided, that You must
+take reasonable precautions to ensure that only Licensees have access to
+such Error Corrections and Shared Modifications. Such precautions shall
+include, without limitation, a password protection scheme limited to
+Licensees and a click-on, download certification of Licensee status
+required of those attempting to download from the server. An example of
+an acceptable certification is attached as Attachment A-2.
+
+(c) Notices. All Error Corrections and Shared Modifications You create
+or contribute to must include a file documenting the additions and
+changes You made and the date of such additions and changes. You must
+also include the notice set forth in Attachment A-1 in the file header.
+If it is not possible to put the notice in a particular Source Code file
+due to its structure, then You must include the notice in a location
+(such as a relevant directory file), where a recipient would be most
+likely to look for such a notice.
+
+(d) Redistribution.
+
+(i) Source. Covered Code may be distributed in Source Code form only to
+another Licensee (except for students as provided below). You may not
+offer or impose any terms on any Covered Code that alter the rights,
+requirements, or responsibilities of such Licensee. You may distribute
+Covered Code to students for use in connection with their course work
+and research projects undertaken at accredited educational institutions.
+Such students need not be Licensees, but must be given a copy of the
+notice set forth in Attachment A-3 and such notice must also be included
+in a file header or prominent location in the Source Code made available
+to such students.
+
+(ii) Executable. You may distribute Executable version(s) of Covered
+Code to Licensees and other third parties only for the purpose of
+evaluation and comment in connection with Research Use by You and under
+a license of Your choice, but which limits use of such Executable
+version(s) of Covered Code only to that purpose.
+
+(iii) Modified Class, Interface and Package Naming. In connection with
+Research Use by You only, You may use Original Contributor's class,
+Interface and package names only to accurately reference or invoke the
+Source Code files You modify. Original Contributor grants to You a
+limited license to the extent necessary for such purposes.
+
+(iv) You expressly agree that any distribution, in whole or in part, of
+Modifications developed by You shall only be done pursuant to the terms
+and conditions of this License.
+
+(e) Extensions.
+
+(i) Covered Code. You may not include any Source Code of Community Code
+in any Extensions. You may include the compiled Header Files of
+Community Code in an Extension provided that Your use of the Covered
+Code, including Heading Files, complies with the Commercial Use License,
+the TCK and all other terms of this License.
+
+(ii) Publication. No later than the date on which You first distribute
+such Extension for Commercial Use, You must publish to the industry, on
+a non-confidential basis and free of all copyright restrictions with
+respect to reproduction and use, an accurate and current specification
+for any Extension. In addition, You must make available an appropriate
+test suite, pursuant to the same rights as the specification,
+sufficiently detailed to allow any third party reasonably skilled in the
+technology to produce implementations of the Extension compatible with
+the specification. Such test suites must be made available as soon as
+reasonably practicable but, in no event, later than ninety (90) days
+after Your first Commercial Use of the Extension. You must use
+reasonable efforts to promptly clarify and correct the specification and
+the test suite upon written request by Original Contributor.
+
+(iii) Open. You agree to refrain from enforcing any Intellectual
+Property Rights You may have covering any interface(s) of Your
+Extension, which would prevent the implementation of such interface(s)
+by Original Contributor or any Licensee. This obligation does not
+prevent You from enforcing any Intellectual Property Right You have that
+would otherwise be infringed by an implementation of Your Extension.
+
+(iv) Interface Modifications and Naming. You may not modify or add to
+the GUID space * * "xxxxxxxx-0901-11d1-8B06-00A024406D59" or any other
+GUID space designated by Original Contributor. You may not modify any
+Interface prefix provided with the Covered Code or any other prefix
+designated by Original Contributor.* *
+
+* *
+
+(f) You agree that any Specifications provided to You by Original
+Contributor are confidential and proprietary information of Original
+Contributor. You must maintain the confidentiality of the Specifications
+and may not disclose them to any third party without Original
+Contributor's prior written consent. You may only use the Specifications
+under the terms of this License and only for the purpose of implementing
+the terms of this License with respect to Covered Code. You agree not
+use, copy or distribute any such Specifications except as provided in
+writing by Original Contributor.
+
+3.2 Commercial Use License.
+
+You may not make Commercial Use of any Covered Code unless You and
+Original Contributor have executed a copy of the Commercial Use and
+Trademark License attached as Attachment D.
+
+*4. Versions of the License.*
+
+4.1 License Versions.
+
+Original Contributor may publish revised versions of the License from
+time to time. Each version will be given a distinguishing version number.
+
+4.2 Effect.
+
+Once a particular version of Covered Code has been provided under a
+version of the License, You may always continue to use such Covered Code
+under the terms of that version of the License. You may also choose to
+use such Covered Code under the terms of any subsequent version of the
+License. No one other than Original Contributor has the right to
+promulgate License versions.
+
+4.3 Multiple-Licensed Code.
+
+Original Contributor may designate portions of the Covered Code as
+"Multiple-Licensed." "Multiple-Licensed" means that the Original
+Contributor permits You to utilize those designated portions of the
+Covered Code under Your choice of this License or the alternative
+license(s), if any, specified by the Original Contributor in an
+Attachment to this License.
+
+*5. Disclaimer of Warranty.*
+
+5.1 COVERED CODE PROVIDED AS IS.
+
+COVERED CODE IS PROVIDED UNDER THIS LICENSE "AS IS," WITHOUT WARRANTY OF
+ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION,
+WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT
+FOR A PARTICULAR PURPOSE OR NON-INFRINGING. YOU AGREE TO BEAR THE ENTIRE
+RISK IN CONNECTION WITH YOUR USE AND DISTRIBUTION OF COVERED CODE UNDER
+THIS LICENSE. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART
+OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER
+EXCEPT SUBJECT TO THIS DISCLAIMER.
+
+5.2 Not Designed for High Risk Activities.
+
+You acknowledge that Original Code, Upgraded Code and Specifications are
+not designed or intended for use in high risk activities including, but
+not limited to: (i) on-line control of aircraft, air traffic, aircraft
+navigation or aircraft communications; or (ii) in the design,
+construction, operation or maintenance of any nuclear facility. Original
+Contributor disclaims any express or implied warranty of fitness for
+such uses.
+
+*6. Termination.*
+
+6.1 By You.
+
+You may terminate this Research Use license at anytime by providing
+written notice to Original Contributor.
+
+6.2 By Original Contributor.
+
+This License and the rights granted hereunder will terminate:
+
+(i) automatically if You fail to comply with the terms of this License
+and fail to cure such breach within 30 days of receipt of written notice
+of the breach;
+
+(ii) immediately in the event of circumstances specified in Sections 7.1
+and 8.4; or
+
+(iii) at Original Contributor's discretion upon any action initiated by
+You (including by cross-claim or counter claim) alleging that use or
+distribution by Original Contributor or any Licensee, of Original Code,
+Upgraded Code, Error Corrections, Shared Modifications or Specifications
+infringe a patent owned or controlled by You.
+
+6.3 Effective of Termination.
+
+Upon termination, You agree to discontinue use of and destroy all copies
+of Covered Code in Your possession. All sublicenses to the Covered Code
+which You have properly granted shall survive any termination of this
+License. Provisions that, by their nature, should remain in effect
+beyond the termination of this License shall survive including, without
+limitation, Sections 2.2, 3, 5, 7 and 8.
+
+6.4 No Compensation.
+
+Each party waives and releases the other from any claim to compensation
+or indemnity for permitted or lawful termination of the business
+relationship established by this License.
+
+*7. Liability.*
+
+7.1 Infringement. Should any of the Original Code, Upgraded Code, TCK or
+Specifications ("Materials") become the subject of a claim of
+infringement, Original Contributor may, at its sole option, (i) attempt
+to procure the rights necessary for You to continue using the Materials,
+(ii) modify the Materials so that they are no longer infringing, or
+(iii) terminate Your right to use the Materials, immediately upon
+written notice, and refund to You the amount, if any, having then
+actually been paid by You to Original Contributor for the Original Code,
+Upgraded Code and TCK, depreciated on a straight line, five year basis.
+
+7.2 LIMITATION OF LIABILITY. TO THE FULL EXTENT ALLOWED BY APPLICABLE
+LAW, ORIGINAL CONTRIBUTOR'S LIABILITY TO YOU FOR CLAIMS RELATING TO THIS
+LICENSE, WHETHER FOR BREACH OR IN TORT, SHALL BE LIMITED TO ONE HUNDRED
+PERCENT (100%) OF THE AMOUNT HAVING THEN ACTUALLY BEEN PAID BY YOU TO
+ORIGINAL CONTRIBUTOR FOR ALL COPIES LICENSED HEREUNDER OF THE PARTICULAR
+ITEMS GIVING RISE TO SUCH CLAIM, IF ANY, DURING THE TWELVE MONTHS
+PRECEDING THE CLAIMED BREACH. IN NO EVENT WILL YOU (RELATIVE TO YOUR
+SHARED MODIFICATIONS OR ERROR CORRECTIONS) OR ORIGINAL CONTRIBUTOR BE
+LIABLE FOR ANY INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
+DAMAGES IN CONNECTION WITH OR RISING OUT OF THIS LICENSE (INCLUDING,
+WITHOUT LIMITATION, LOSS OF PROFITS, USE, DATA, OR OTHER ECONOMIC
+ADVANTAGE), HOWEVER IT ARISES AND ON ANY THEORY OF LIABILITY, WHETHER IN
+AN ACTION FOR CONTRACT, STRICT LIABILITY OR TORT (INCLUDING NEGLIGENCE)
+OR OTHERWISE, WHETHER OR NOT YOU OR ORIGINAL CONTRIBUTOR HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE AND NOTWITHSTANDING THE
+FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY.
+
+*8. Miscellaneous.*
+
+8.1 Trademark.
+
+You shall not use any Trademark unless You and Original Contributor
+execute a copy of the Commercial Use and Trademark License Agreement
+attached hereto as Attachment D. Except as expressly provided in the
+License, You are granted no right, title or license to, or interest in,
+any Trademarks. Whether or not You and Original Contributor enter into
+the Trademark License, You agree not to (i) challenge Original
+Contributor's ownership or use of Trademarks; (ii) attempt to register
+any Trademarks, or any mark or logo substantially similar thereto; or
+(iii) incorporate any Trademarks into Your own trademarks, product
+names, service marks, company names, or domain names.
+
+8.2 Integration.
+
+This License represents the complete agreement concerning the subject
+matter hereof.
+
+8.3 Assignment.
+
+Original Contributor may assign this License, and its rights and
+obligations hereunder, in its sole discretion. You may assign the
+Research Use portions of this License and the TCK license to a third
+party upon prior written notice to Original Contributor (which may be
+provided electronically via the Community Web-Server). You may not
+assign the Commercial Use and Trademark license, the Add-On Technology
+License, or the Add-On Technology Source Code Porting License, including
+by way of merger (regardless of whether You are the surviving entity) or
+acquisition, without Original Contributor's prior written consent.
+
+8.4 Severability.
+
+If any provision of this License is held to be unenforceable, such
+provision shall be reformed only to the extent necessary to make it
+enforceable. Notwithstanding the foregoing, if You are prohibited by law
+from fully and specifically complying with Sections 2.2 or 3, this
+License will immediately terminate and You must immediately discontinue
+any use of Covered Code.
+
+8.5 Governing Law.
+
+This License shall be governed by the laws of the United States and the
+State of Washington, as applied to contracts entered into and to be
+performed in Washington between Washington residents. The application of
+the United Nations Convention on Contracts for the International Sale of
+Goods is expressly excluded. You agree that the state and federal courts
+located in Seattle, Washington have exclusive jurisdiction over any
+claim relating to the License, including contract and tort claims.
+
+8.6 Dispute Resolution.
+
+a) Arbitration. Any dispute arising out of or relating to this License
+shall be finally settled by arbitration as set out herein, except that
+either party may bring any action, in a court of competent jurisdiction
+(which jurisdiction shall be exclusive), with respect to any dispute
+relating to such party's Intellectual Property Rights or with respect to
+Your compliance with the TCK license. Arbitration shall be administered:
+(i) by the American Arbitration Association (AAA), (ii) in accordance
+with the rules of the United Nations Commission on International Trade
+Law (UNCITRAL) (the "Rules") in effect at the time of arbitration as
+modified herein; and (iii) the arbitrator will apply the substantive
+laws of Washington and the United States. Judgment upon the award
+rendered by the arbitrator may be entered in any court having
+jurisdiction to enforce such award.
+
+b) Arbitration language, venue and damages. All arbitration proceedings
+shall be conducted in English by a single arbitrator selected in
+accordance with the Rules, who must be fluent in English and be either a
+retired judge or practicing attorney having at least ten (10) years
+litigation experience and be reasonably familiar with the technology
+matters relative to the dispute. Unless otherwise agreed, arbitration
+venue shall be in Seattle, Washington. The arbitrator may award monetary
+damages only and nothing shall preclude either party from seeking
+provisional or emergency relief from a court of competent jurisdiction.
+The arbitrator shall have no authority to award damages in excess of
+those permitted in this License and any such award in excess is void.
+All awards will be payable in U.S. dollars and may include, for the
+prevailing party (i) pre-judgment award interest, (ii) reasonable
+attorneys' fees incurred in connection with the arbitration, and (iii)
+reasonable costs and expenses incurred in enforcing the award. The
+arbitrator will order each party to produce identified documents and
+respond to no more than twenty-five single question interrogatories.
+
+8.7 Construction.
+
+Any law or regulation, which provides that the language of a contract
+shall be construed against the drafter, shall not apply to this License.
+
+8.8 U.S. Government End Users.
+
+The Covered Code is a "commercial item," as that term is defined in 48
+C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer software"
+and "commercial computer software documentation," as such terms are used
+in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and
+48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government
+End Users acquire Covered Code with only those rights set forth herein.
+You agree to pass this notice to our licensees.
+
+8.9 Marketing Activities.
+
+Licensee hereby grants Original Contributor a non-exclusive,
+non-transferable, limited license to use the Licensee's company name and
+logo ("Licensee Marks") in any presentations, press releases, or
+marketing materials solely for the purpose of identifying Licensee as a
+member of the Helix Community. Licensee shall provide samples of
+Licensee Marks to Original Contributor upon request by Original
+Contributor. Original Contributor acknowledges that the Licensee Marks
+are the trademarks of Licensee. Original Contributor shall not use the
+Licensee Marks in a way that may imply that Original Contributor is an
+agency or branch of Licensee. Original Contributor understands and
+agrees that the use of any Licensee Marks in connection with this
+Agreement shall not create any right, title or interest, in, or to the
+Licensee Marks or any Licensee trademarks and that all such use and
+goodwill associated with any such trademarks will inure to the benefit
+of Licensee. Further the Original Contributor will stop usage of the
+Licensee Marks upon Licensee's request.
+
+8.10 Press Announcements.
+
+You may make press announcements or other public statements regarding
+this License without the prior written consent of the Original
+Contributor, if Your statement is limited to announcing the licensing of
+the Covered Code or the availability of Your Product and its
+compatibility with the Covered Code. All other public announcements
+regarding this license require the prior written consent of the Original
+Contributor. Consent requests are welcome at press@helixcommunity.org.
+
+8.11 International Use.
+
+a) Export/Import laws. Covered Code is subject to U.S. export control
+laws and may be subject to export or import regulations in other
+countries. Each party agrees to comply strictly with all such laws and
+regulations and acknowledges their responsibility to obtain such
+licenses to export, re-export, or import as may be required. You agree
+to pass these obligations to Your licensees.
+
+b) Intellectual Property Protection. Due to limited intellectual
+property protection and enforcement in certain countries, You agree not
+to redistribute the Original Code, Upgraded Code, TCK and Specifications
+to any country on the list of restricted countries on the Community Web
+Server.
+
+8.12 Language.
+
+This License is in the English language only, which language shall be
+controlling in all respects, and all versions of this License in any
+other language shall be for accommodation only and shall not be binding
+on the parties to this License. All communications and notices made or
+given pursuant to this License, and all documentation and support to be
+provided, unless otherwise noted, shall be in the English language.
+
+PLEASE READ THE TERMS OF THIS LICENSE CAREFULLY. BY CLICKING ON THE
+"ACCEPT" BUTTON BELOW YOU ARE ACCEPTING AND AGREEING TO THE TERMS AND
+CONDITIONS OF THIS LICENSE WITH REALNETWORKS, INC. IF YOU ARE AGREEING
+TO THIS LICENSE ON BEHALF OF A COMPANY, YOU REPRESENT THAT YOU ARE
+AUTHORIZED TO BIND THE COMPANY TO SUCH A LICENSE. WHETHER YOU ARE ACTING
+ON YOUR OWN BEHALF, OR REPRESENTING A COMPANY, YOU MUST BE OF MAJORITY
+AGE AND BE OTHERWISE COMPETENT TO ENTER INTO CONTRACTS. IF YOU DO NOT
+MEET THIS CRITERIA OR YOU DO NOT AGREE TO ANY OF THE TERMS AND
+CONDITIONS OF THIS LICENSE, CLICK ON THE REJECT BUTTON TO EXIT.
+
+
+    GLOSSARY
+
+1. *"Added Value"* means code which:
+
+(i) has a principal purpose which is substantially different from that
+of the stand-alone Technology;
+
+(ii) represents a significant functional and value enhancement to the
+Technology;
+
+(iii) operates in conjunction with the Technology; and
+
+(iv) is not marketed as a technology which replaces or substitutes for
+the Technology
+
+2. "*Applicable Patent Rights*" mean: (a) in the case where Original
+Contributor is the grantor of rights, claims of patents that (i) are now
+or hereafter acquired, owned by or assigned to Original Contributor and
+(ii) are necessarily infringed by using or making the Original Code or
+Upgraded Code, including Modifications provided by Original Contributor,
+alone and not in combination with other software or hardware; and (b) in
+the case where Licensee is the grantor of rights, claims of patents that
+(i) are now or hereafter acquired, owned by or assigned to Licensee and
+(ii) are infringed (directly or indirectly) by using or making
+Licensee's Modifications or Error Corrections, taken alone or in
+combination with Covered Code.
+
+3. "*Application Programming Interfaces (APIs)"* means the interfaces,
+associated header files, service provider interfaces, and protocols that
+enable a device, application, Operating System, or other program to
+obtain services from or make requests of (or provide services in
+response to requests from) other programs, and to use, benefit from, or
+rely on the resources, facilities, and capabilities of the relevant
+programs using the APIs. APIs includes the technical documentation
+describing the APIs, the Source Code constituting the API, and any
+Header Files used with the APIs.
+
+4. "*Commercial Use*" means any use (internal or external), copying,
+sublicensing or distribution (internal or external), directly or
+indirectly of Covered Code by You other than Your Research Use of
+Covered Code within Your business or organization or in conjunction with
+other Licensees with equivalent Research Use rights. Commercial Use
+includes any use of the Covered Code for direct or indirect commercial
+or strategic gain, advantage or other business purpose. Any Commercial
+Use requires execution of Attachment D by You and Original Contributor.
+
+5. "*Community Code*" means the Original Code, Upgraded Code, Error
+Corrections, Shared Modifications, or any combination thereof.
+
+6. "*Community Webserver(s)"* means the webservers designated by
+Original Contributor for access to the Original Code, Upgraded Code, TCK
+and Specifications and for posting Error Corrections and Shared
+Modifications.
+
+7. "*Compliant Covered Code*" means Covered Code that complies with the
+requirements of the TCK.
+
+8. "*Contributor*" means each Licensee that creates or contributes to
+the creation of any Error Correction or Shared Modification.
+
+9. "*Covered Code*" means the Original Code, Upgraded Code,
+Modifications, or any combination thereof.
+
+10. "*Error Correction*" means any change made to Community Code which
+conforms to the Specification and corrects the adverse effect of a
+failure of Community Code to perform any function set forth in or
+required by the Specifications.
+
+11. "*Executable*" means Covered Code that has been converted from
+Source Code to the preferred form for execution by a computer or digital
+processor (e.g. binary form).
+
+12. "*Extension(s)"* means any additional Interfaces developed by or for
+You which: (i) are designed for use with the Technology; (ii) constitute
+an API for a library of computing functions or services; and (iii) are
+disclosed or otherwise made available to third party software developers
+for the purpose of developing software which invokes such additional
+Interfaces. The foregoing shall not apply to software developed by Your
+subcontractors to be exclusively used by You.
+
+13. "*Header File(s)"* means that portion of the Source Code that
+provides the names and types of member functions, data members, class
+definitions, and interface definitions necessary to implement the APIs
+for the Covered Code. Header Files include, files specifically
+designated by Original Contributor as Header Files. Header Files do not
+include the code necessary to implement the functionality underlying the
+Interface.
+
+14. *"Helix DNA Server Technology"* means the program(s) that implement
+the Helix Universal Server streaming engine for the Technology as
+defined in the Specification.
+
+15. *"Helix DNA Client Technology"* means the Covered Code that
+implements the RealOne Player engine as defined in the Specification.
+
+16. *"Helix DNA Producer Technology"* means the Covered Code that
+implements the Helix Producer engine as defined in the Specification.
+
+17. *"Helix DNA Technology"* means the Helix DNA Server Technology, the
+Helix DNA Client Technology, the Helix DNA Producer Technology and other
+Helix technologies designated by Original Contributor.
+
+18. "*Intellectual Property Rights*" means worldwide statutory and
+common law rights associated solely with (i) Applicable Patent Rights;
+(ii) works of authorship including copyrights, copyright applications,
+copyright registrations and "moral rights"; (iii) the protection of
+trade and industrial secrets and confidential information; and (iv)
+divisions, continuations, renewals, and re-issuances of the foregoing
+now existing or acquired in the future.
+
+19. *"Interface*" means interfaces, functions, properties, class
+definitions, APIs, Header Files, GUIDs, V-Tables, and/or protocols
+allowing one piece of software, firmware or hardware to communicate or
+interoperate with another piece of software, firmware or hardware.
+
+20. "*Internal Deployment Use*" means use of Compliant Covered Code
+(excluding Research Use) within Your business or organization only by
+Your employees and/or agents on behalf of Your business or organization,
+but not to provide services, including content distribution, to third
+parties, subject to execution of Attachment D by You and Original
+Contributor, if required.
+
+21. "*Licensee*" means any party that has entered into and has in effect
+a version of this License with Original Contributor.
+
+22. "*MIME type*" means a description of what type of media or other
+content is in a file, including by way of example but not limited to
+'audio/x-pn-realaudio-plugin.'
+
+23. "*Modification(s)"* means (i) any addition to, deletion from and/or
+change to the substance and/or structure of the Covered Code, including
+Interfaces; (ii) the combination of any Covered Code and any previous
+Modifications; (iii) any new file or other representation of computer
+program statements that contains any portion of Covered Code; and/or
+(iv) any new Source Code implementing any portion of the Specifications.
+
+24. "*MP3 Patents*" means any patents necessary to make, use or sell
+technology implementing any portion of the specification developed by
+the Moving Picture Experts Group known as MPEG-1 Audio Layer-3 or MP3,
+including but not limited to all past and future versions, profiles,
+extensions, parts and amendments relating to the MP3 specification.
+
+25. "*MPEG-4 Patents*" means any patents necessary to make, use or sell
+technology implementing any portion of the specification developed by
+the Moving Pictures Experts Group known as MPEG-4, including but not
+limited to all past and future versions, profiles, extensions, parts and
+amendments relating to the MPEG-4 specification.
+
+26. "*Original Code*" means the initial Source Code for the Technology
+as described on the Community Web Server.
+
+27. "*Original Contributor*" means RealNetworks, Inc., its affiliates
+and its successors and assigns.
+
+28. "*Original Contributor MIME Type*" means the MIME registry, browser
+preferences, or local file/protocol associations invoking any Helix DNA
+Client-based application, including the RealOne Player, for playback of
+RealAudio, RealVideo, other RealMedia MIME types or datatypes (e.g.,
+.ram, .rnx, .rpm, .ra, .rm, .rp, .rt, .rf, .prx, .mpe, .rmp, .rmj, .rav,
+.rjs, .rmx, .rjt, .rms), and any other Original Contributor-specific or
+proprietary MIME types that Original Contributor may introduce in the
+future.
+
+29. "*Personal Use*" means use of Covered Code by an individual solely
+for his or her personal, private and non-commercial purposes. An
+individual's use of Covered Code in his or her capacity as an officer,
+employee, member, independent contractor or agent of a corporation,
+business or organization (commercial or non-commercial) does not qualify
+as Personal Use.
+
+30. "*RealMedia File Format*" means the file format designed and
+developed by RealNetworks for storing multimedia data and used to store
+RealAudio and RealVideo encoded streams. Valid RealMedia File Format
+extensions include: .rm, .rmj, .rmc, .rmvb, .rms.
+
+31. "*RCSL Webpage*" means the RealNetworks Community Source License
+webpage located at https://www.helixcommunity.org/content/rcsl or such
+other URL that Original Contributor may designate from time to time.
+
+32. "*Reformatted Specifications*" means any revision to the
+Specifications which translates or reformats the Specifications (as for
+example in connection with Your documentation) but which does not alter,
+subset or superset * *the functional or operational aspects of the
+Specifications.
+
+33. "*Research Use*" means use and distribution of Covered Code only for
+Your Personal Use, research or development use and expressly excludes
+Internal Deployment Use and Commercial Use. Research Use also includes
+use of Covered Code to teach individuals how to use Covered Code.
+
+34. "*Shared Modifications*" means Modifications that You distribute or
+use for a Commercial Use, in addition to any Modifications provided by
+You, at Your option, pursuant to Section 2.2, or received by You from a
+Contributor pursuant to Section 2.3.
+
+35. "*Source Code*" means the preferred form of the Covered Code for
+making modifications to it, including all modules it contains, plus any
+associated interface definition files, scripts used to control
+compilation and installation of an Executable, or source code
+differential comparisons against either the Original Code or another
+well known, available Covered Code of the Contributor's choice. The
+Source Code can be in a compressed or archival form, provided the
+appropriate decompression or de-archiving software is widely available
+for no charge.
+
+36. "*Specifications*" means the specifications for the Technology and
+other documentation, as designated on the Community Web Server, as may
+be revised by Original Contributor from time to time.
+
+37. "*Trademarks*" means Original Contributor's trademarks and logos,
+including, but not limited to, RealNetworks, RealAudio, RealVideo,
+RealOne, RealSystem, SureStream, Helix, Helix DNA and other trademarks
+whether now used or adopted in the future.
+
+38. "*Technology*" means the technology described in Attachment B, and
+Upgrades.
+
+39. "*Technology Compatibility Kit"* or *"TCK*" means the test programs,
+procedures, acceptance criteria and/or other requirements, designated by
+Original Contributor for use in verifying compliance of Covered Code
+with the Specifications, in conjunction with the Original Code and
+Upgraded Code. Original Contributor may, in its sole discretion and from
+time to time, revise a TCK to correct errors and/or omissions and in
+connection with Upgrades.
+
+40. "*Upgrade(s)"* means new versions of Technology designated
+exclusively by Original Contributor as an "Upgrade" and released by
+Original Contributor from time to time under the terms of the License.
+
+41. "*Upgraded Code*" means the Source Code and/or Executables for
+Upgrades, possibly including Modifications made by Contributors.
+
+42. *"User's Guide"* means the users guide for the TCK which Original
+Contributor makes available to You to provide direction in how to run
+the TCK and properly interpret the results, as may be revised by
+Original Contributor from time to time.
+
+43. "*You(r)*" means an individual, or a legal entity acting by and
+through an individual or individuals, exercising rights either under
+this License or under a future version of this License issued pursuant
+to Section 4.1. For legal entities, "You(r)" includes any entity that by
+majority voting interest controls, is controlled by, or is under common
+control with You.
+
+44. "*Your Products*" means any (i) hardware products You distribute
+integrating the Covered Code; (ii) any software products You distribute
+with the Covered Code that utilize the APIs of the Covered Code; or
+(iii) any services You provide using the Covered Code.
+
+
+  ATTACHMENT A
+
+REQUIRED NOTICES
+
+
+    ATTACHMENT A-1
+
+REQUIRED IN ALL CASES
+
+Notice to be included in header file of all Error Corrections and Shared
+Modifications:
+
+Portions Copyright 1994-2003 <20> RealNetworks, Inc. All rights reserved.
+
+The contents of this file, and the files included with this file, are
+subject to the current version of RealNetworks Community Source License
+Version 1.1 (the "License"). You may not use this file except in
+compliance with the License executed by both You and RealNetworks. You
+may obtain a copy of the License at *
+https://www.helixcommunity.org/content/rcsl.* You may also obtain a copy
+of the License by contacting RealNetworks directly. Please see the
+License for the rights, obligations and limitations governing use of the
+contents of the file.
+
+This file is part of the Helix DNA technology. RealNetworks, Inc., is
+the developer of the Original code and owns the copyrights in the
+portions it created.
+
+This file, and the files included with this file, are distributed on an
+'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
+LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+
+Contributor(s):
+
+_______________________________________________
+
+Technology Compatibility Kit Test Suite(s) Location:
+
+________________________________
+
+
+    ATTACHMENT A-2
+
+SAMPLE LICENSEE CERTIFICATION
+
+"By clicking the `Agree' button below, You certify that You are a
+Licensee in good standing under the RealNetworks Community Source
+License, ("License") and that Your access, use and distribution of code
+and information You may obtain at this site is subject to the License.
+If You are not a Licensee under the RealNetworks Community Source
+License You agree not to download, copy or use the Helix DNA technology.
+
+
+    ATTACHMENT A-3
+
+REQUIRED STUDENT NOTIFICATION
+
+"This software and related documentation has been obtained by Your
+educational institution subject to the RealNetworks Community Source
+License. You have been provided access to the software and related
+documentation for use only in connection with your course work and
+research activities as a matriculated student of Your educational
+institution. Any other use is expressly prohibited.
+
+THIS SOFTWARE AND RELATED DOCUMENTATION CONTAINS PROPRIETARY MATERIAL OF
+REALNETWORKS, INC, WHICH ARE PROTECTED BY VARIOUS INTELLECTUAL PROPERTY
+RIGHTS.
+
+You may not use this file except in compliance with the License. You may
+obtain a copy of the License on the web at
+https://www.helixcommunity.org/content/rcsl.
+
+*
+*
+
+
+  ATTACHMENT B
+
+Description of Technology
+
+Helix DNA, which consists of Helix DNA Client, Helix DNA Server and
+Helix DNA Producer.
+
+Description of "Technology"
+
+Helix DNA Technology v1.0 as described on the Community Web Server.
+
+
+  ATTACHMENT C
+
+TECHNOLOGY COMPATIBILITY KIT LICENSE
+
+The following license is effective for the *Helix DNA* Technology
+Compatibility Kit - as described on the Community Web Server. The
+Technology Compatibility Kit(s) for the Technology specified in
+Attachment B may be accessed at the Community Web Server.
+
+1. TCK License.
+
+1.1 Grants to use TCK
+
+Subject to the terms and restrictions set forth below and the
+RealNetworks Community Source License, and the Research Use license,
+Original Contributor grants to You a worldwide, non-exclusive,
+non-transferable license, to the extent of Original Contributor's
+Intellectual Property Rights in the TCK (without the right to
+sublicense), to use the TCK to develop and test Covered Code.
+
+1.2 TCK Use Restrictions.
+
+You are not authorized to create derivative works of the TCK or use the
+TCK to test any implementation of the Specification that is not Covered
+Code. You may not publish Your test results or make claims of
+comparative compatibility with respect to other implementations of the
+Specification. In consideration for the license grant in Section 1.1
+above You agree not to develop Your own tests that are intended to
+validate conformation with the Specification.
+
+2. Test Results.
+
+You agree to provide to Original Contributor or the third party test
+facility if applicable, Your test results that demonstrate that Covered
+Code is Compliant Covered Code and that Original Contributor may publish
+or otherwise distribute such test results.
+
+PLEASE READ THE TERMS OF THIS LICENSE CAREFULLY. BY CLICKING ON THE
+"ACCEPT" BUTTON BELOW YOU ARE ACCEPTING AND AGREEING TO THE TERMS AND
+CONDITIONS OF THIS LICENSE WITH THE ORIGINAL CONTRIBUTOR, REALNETWORKS,
+INC. IF YOU ARE AGREEING TO THIS LICENSE ON BEHALF OF A COMPANY, YOU
+REPRESENT THAT YOU ARE AUTHORIZED TO BIND THE COMPANY TO SUCH A LICENSE.
+WHETHER YOU ARE ACTING ON YOUR OWN BEHALF, OR REPRESENTING A COMPANY,
+YOU MUST BE OF MAJORITY AGE AND BE OTHERWISE COMPETENT TO ENTER INTO
+CONTRACTS. IF YOU DO NOT MEET THIS CRITERIA OR YOU DO NOT AGREE TO ANY
+OF THE TERMS AND CONDITIONS OF THIS LICENSE, CLICK ON THE REJECT BUTTON
+TO EXIT.
+
+*ACCEPT / REJECT
+*
+
+*
+*
+
+*To agree to the R&D/academic terms of this license, please register
+<https://www.helixcommunity.org/2002/intro/why-register> on the site --
+you will then be given a chance to agree to the clickwrap RCSL
+<https://reguseronly.helixcommunity.org/2002/clickwrap/rcsl-clickwrap>
+R&D License
+<https://reguseronly.helixcommunity.org/2002/clickwrap/rcsl-clickwrap>
+and gain access to the RCSL-licensed source code.  To build or deploy
+commercial applications based on the RCSL, you will need to agree to the
+Commercial Use license attachments
+<https://www.helixcommunity.org/content/rcsl-attachments>*
+
+
+
Index: helix-libs/clientapps/clutter/RPSL.txt
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/RPSL.txt	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,518 @@
+RealNetworks Public Source License Version 1.0
+(Rev. Date October 28, 2002)
+
+1. General Definitions. This License applies to any program or other work which
+RealNetworks, Inc., or any other entity that elects to use this license,
+("Licensor") makes publicly available and which contains a notice placed by
+Licensor identifying such program or work as "Original Code" and stating that it
+is subject to the terms of this RealNetworks Public Source License version 1.0
+(or subsequent version thereof) ("License"). You are not required to accept this
+License. However, nothing else grants You permission to use, copy, modify or
+distribute the software or its derivative works. These actions are prohibited by
+law if You do not accept this License. Therefore, by modifying, copying or
+distributing the software (or any work based on the software), You indicate your
+acceptance of this License to do so, and all its terms and conditions. In
+addition, you agree to the terms of this License by clicking the Accept button
+or downloading the software. As used in this License:
+
+1.1 "Applicable Patent Rights" mean: (a) in the case where Licensor is the
+grantor of rights, claims of patents that (i) are now or hereafter acquired,
+owned by or assigned to Licensor and (ii) are necessarily infringed by using or
+making the Original Code alone and not in combination with other software or
+hardware; and (b) in the case where You are the grantor of rights, claims of
+patents that (i) are now or hereafter acquired, owned by or assigned to You and
+(ii) are infringed (directly or indirectly) by using or making Your
+Modifications, taken alone or in combination with Original Code.
+
+1.2 "Compatible Source License" means any one of the licenses listed on Exhibit
+B or at https://www.helixcommunity.org/content/complicense or other licenses
+specifically identified by Licensor in writing. Notwithstanding any term to the
+contrary in any Compatible Source License, any code covered by any Compatible
+Source License that is used with Covered Code must be made readily available in
+Source Code format for royalty-free use under the terms of the Compatible Source
+License or this License.
+
+1.3 "Contributor" means any person or entity that creates or contributes to the
+creation of Modifications.
+
+1.4 "Covered Code" means the Original Code, Modifications, the combination of
+Original Code and any Modifications, and/or any respective portions thereof.
+
+1.5 "Deploy" means to use, sublicense or distribute Covered Code other than for
+Your internal research and development (R&D) and/or Personal Use, and includes
+without limitation, any and all internal use or distribution of Covered Code
+within Your business or organization except for R&D use and/or Personal Use, as
+well as direct or indirect sublicensing or distribution of Covered Code by You
+to any third party in any form or manner.
+
+1.6 "Derivative Work" means either the Covered Code or any derivative work under
+United States copyright law, and including any work containing or including any
+portion of the Covered Code or Modifications, either verbatim or with
+modifications and/or translated into another language. Derivative Work also
+includes any work which combines any portion of Covered Code or Modifications
+with code not otherwise governed by the terms of this License.
+
+1.7 "Externally Deploy" means to Deploy the Covered Code in any way that may be
+accessed or used by anyone other than You, used to provide any services to
+anyone other than You, or used in any way to deliver any content to anyone other
+than You, whether the Covered Code is distributed to those parties, made
+available as an application intended for use over a computer network, or used to
+provide services or otherwise deliver content to anyone other than You.
+
+1.8. "Interface" means interfaces, functions, properties, class definitions,
+APIs, header files, GUIDs, V-Tables, and/or protocols allowing one piece of
+software, firmware or hardware to communicate or interoperate with another piece
+of software, firmware or hardware.
+
+1.9 "Modifications" mean any addition to, deletion from, and/or change to, the
+substance and/or structure of the Original Code, any previous Modifications, the
+combination of Original Code and any previous Modifications, and/or any
+respective portions thereof. When code is released as a series of files, a
+Modification is: (a) any addition to or deletion from the contents of a file
+containing Covered Code; and/or (b) any new file or other representation of
+computer program statements that contains any part of Covered Code.
+
+1.10 "Original Code" means (a) the Source Code of a program or other work as
+originally made available by Licensor under this License, including the Source
+Code of any updates or upgrades to such programs or works made available by
+Licensor under this License, and that has been expressly identified by Licensor
+as such in the header file(s) of such work; and (b) the object code compiled
+from such Source Code and originally made available by Licensor under this
+License.
+
+1.11 "Personal Use" means use of Covered Code by an individual solely for his or
+her personal, private and non-commercial purposes. An individual's use of
+Covered Code in his or her capacity as an officer, employee, member, independent
+contractor or agent of a corporation, business or organization (commercial or
+non-commercial) does not qualify as Personal Use.
+
+1.12 "Source Code" means the human readable form of a program or other work that
+is suitable for making modifications to it, including all modules it contains,
+plus any associated interface definition files, scripts used to control
+compilation and installation of an executable (object code).
+
+1.13 "You" or "Your" means an individual or a legal entity exercising rights
+under this License. For legal entities, "You" or "Your" includes any entity
+which controls, is controlled by, or is under common control with, You, where
+"control" means (a) the power, direct or indirect, to cause the direction or
+management of such entity, whether by contract or otherwise, or (b) ownership of
+fifty percent (50%) or more of the outstanding shares or beneficial ownership of
+such entity.
+
+2. Permitted Uses; Conditions & Restrictions. Subject to the terms and
+conditions of this License, Licensor hereby grants You, effective on the date
+You accept this License (via downloading or using Covered Code or otherwise
+indicating your acceptance of this License), a worldwide, royalty-free,
+non-exclusive copyright license, to the extent of Licensor's copyrights cover
+the Original Code, to do the following:
+
+2.1 You may reproduce, display, perform, modify and Deploy Covered Code,
+provided that in each instance:
+
+(a) You must retain and reproduce in all copies of Original Code the copyright
+and other proprietary notices and disclaimers of Licensor as they appear in the
+Original Code, and keep intact all notices in the Original Code that refer to
+this License;
+
+(b) You must include a copy of this License with every copy of Source Code of
+Covered Code and documentation You distribute, and You may not offer or impose
+any terms on such Source Code that alter or restrict this License or the
+recipients' rights hereunder, except as permitted under Section 6;
+
+(c) You must duplicate, to the extent it does not already exist, the notice in
+Exhibit A in each file of the Source Code of all Your Modifications, and cause
+the modified files to carry prominent notices stating that You changed the files
+and the date of any change;
+
+(d) You must make Source Code of all Your Externally Deployed Modifications
+publicly available under the terms of this License, including the license grants
+set forth in Section 3 below, for as long as you Deploy the Covered Code or
+twelve (12) months from the date of initial Deployment, whichever is longer. You
+should preferably distribute the Source Code of Your Deployed Modifications
+electronically (e.g. download from a web site); and
+
+(e) if You Deploy Covered Code in object code, executable form only, You must
+include a prominent notice, in the code itself as well as in related
+documentation, stating that Source Code of the Covered Code is available under
+the terms of this License with information on how and where to obtain such
+Source Code. You must also include the Object Code Notice set forth in Exhibit A
+in the "about" box or other appropriate place where other copyright notices are
+placed, including any packaging materials.
+
+2.2 You expressly acknowledge and agree that although Licensor and each
+Contributor grants the licenses to their respective portions of the Covered Code
+set forth herein, no assurances are provided by Licensor or any Contributor that
+the Covered Code does not infringe the patent or other intellectual property
+rights of any other entity. Licensor and each Contributor disclaim any liability
+to You for claims brought by any other entity based on infringement of
+intellectual property rights or otherwise. As a condition to exercising the
+rights and licenses granted hereunder, You hereby assume sole responsibility to
+secure any other intellectual property rights needed, if any. For example, if a
+third party patent license is required to allow You to make, use, sell, import
+or offer for sale the Covered Code, it is Your responsibility to acquire such
+license(s).
+
+2.3 Subject to the terms and conditions of this License, Licensor hereby grants
+You, effective on the date You accept this License (via downloading or using
+Covered Code or otherwise indicating your acceptance of this License), a
+worldwide, royalty-free, perpetual, non-exclusive patent license under
+Licensor's Applicable Patent Rights to make, use, sell, offer for sale and
+import the Covered Code, provided that in each instance you comply with the
+terms of this License.
+
+3. Your Grants. In consideration of, and as a condition to, the licenses granted
+to You under this License:
+
+(a) You grant to Licensor and all third parties a non-exclusive, perpetual,
+irrevocable, royalty free license under Your Applicable Patent Rights and other
+intellectual property rights owned or controlled by You, to make, sell, offer
+for sale, use, import, reproduce, display, perform, modify, distribute and
+Deploy Your Modifications of the same scope and extent as Licensor's licenses
+under Sections 2.1 and 2.2; and
+
+(b) You grant to Licensor and its subsidiaries a non-exclusive, worldwide,
+royalty-free, perpetual and irrevocable license, under Your Applicable Patent
+Rights and other intellectual property rights owned or controlled by You, to
+make, use, sell, offer for sale, import, reproduce, display, perform,
+distribute, modify or have modified (for Licensor and/or its subsidiaries),
+sublicense and distribute Your Modifications, in any form and for any purpose,
+through multiple tiers of distribution.
+
+(c) You agree not use any information derived from Your use and review of the
+Covered Code, including but not limited to any algorithms or inventions that may
+be contained in the Covered Code, for the purpose of asserting any of Your
+patent rights, or assisting a third party to assert any of its patent rights,
+against Licensor or any Contributor.
+
+4. Derivative Works. You may create a Derivative Work by combining Covered Code
+with other code not otherwise governed by the terms of this License and
+distribute the Derivative Work as an integrated product. In each such instance,
+You must make sure the requirements of this License are fulfilled for the
+Covered Code or any portion thereof, including all Modifications.
+
+4.1 You must cause any Derivative Work that you distribute, publish or
+Externally Deploy, that in whole or in part contains or is derived from the
+Covered Code or any part thereof, to be licensed as a whole at no charge to all
+third parties under the terms of this License and no other license except as
+provided in Section 4.2. You also must make Source Code available for the
+Derivative Work under the same terms as Modifications, described in Sections 2
+and 3, above.
+
+4.2 Compatible Source Licenses. Software modules that have been independently
+developed without any use of Covered Code and which contain no portion of the
+Covered Code, Modifications or other Derivative Works, but are used or combined
+in any way wtih the Covered Code or any Derivative Work to form a larger
+Derivative Work, are exempt from the conditions described in Section 4.1 but
+only to the extent that: the software module, including any software that is
+linked to, integrated with, or part of the same applications as, the software
+module by any method must be wholly subject to one of the Compatible Source
+Licenses. Notwithstanding the foregoing, all Covered Code must be subject to the
+terms of this License. Thus, the entire Derivative Work must be licensed under a
+combination of the RPSL (for Covered Code) and a Compatible Source License for
+any independently developed software modules within the Derivative Work. The
+foregoing requirement applies even if the Compatible Source License would
+ordinarily allow the software module to link with, or form larger works with,
+other software that is not subject to the Compatible Source License. For
+example, although the Mozilla Public License v1.1 allows Mozilla code to be
+combined with proprietary software that is not subject to the MPL, if
+MPL-licensed code is used with Covered Code the MPL-licensed code could not be
+combined or linked with any code not governed by the MPL. The general intent of
+this section 4.2 is to enable use of Covered Code with applications that are
+wholly subject to an acceptable open source license. You are responsible for
+determining whether your use of software with Covered Code is allowed under Your
+license to such software.
+
+4.3 Mere aggregation of another work not based on the Covered Code with the
+Covered Code (or with a work based on the Covered Code) on a volume of a storage
+or distribution medium does not bring the other work under the scope of this
+License. If You deliver the Covered Code for combination and/or integration with
+an application previously provided by You (for example, via automatic updating
+technology), such combination and/or integration constitutes a Derivative Work
+subject to the terms of this License.
+
+5. Exclusions From License Grant. Nothing in this License shall be deemed to
+grant any rights to trademarks, copyrights, patents, trade secrets or any other
+intellectual property of Licensor or any Contributor except as expressly stated
+herein. No right is granted to the trademarks of Licensor or any Contributor
+even if such marks are included in the Covered Code. Nothing in this License
+shall be interpreted to prohibit Licensor from licensing under different terms
+from this License any code that Licensor otherwise would have a right to
+license. Modifications, Derivative Works and/or any use or combination of
+Covered Code with other technology provided by Licensor or third parties may
+require additional patent licenses from Licensor which Licensor may grant in its
+sole discretion. No patent license is granted separate from the Original Code or
+combinations of the Original Code with other software or hardware.
+
+5.1. Trademarks. This License does not grant any rights to use the trademarks or
+trade names owned by Licensor ("Licensor Marks" defined in Exhibit C) or to any
+trademark or trade name belonging to any Contributor. No Licensor Marks may be
+used to endorse or promote products derived from the Original Code other than as
+permitted by the Licensor Trademark Policy defined in Exhibit C.
+
+6. Additional Terms. You may choose to offer, and to charge a fee for, warranty,
+support, indemnity or liability obligations and/or other rights consistent with
+the scope of the license granted herein ("Additional Terms") to one or more
+recipients of Covered Code. However, You may do so only on Your own behalf and
+as Your sole responsibility, and not on behalf of Licensor or any Contributor.
+You must obtain the recipient's agreement that any such Additional Terms are
+offered by You alone, and You hereby agree to indemnify, defend and hold
+Licensor and every Contributor harmless for any liability incurred by or claims
+asserted against Licensor or such Contributor by reason of any such Additional
+Terms.
+
+7. Versions of the License. Licensor may publish revised and/or new versions of
+this License from time to time. Each version will be given a distinguishing
+version number. Once Original Code has been published under a particular version
+of this License, You may continue to use it under the terms of that version. You
+may also choose to use such Original Code under the terms of any subsequent
+version of this License published by Licensor. No one other than Licensor has
+the right to modify the terms applicable to Covered Code created under this
+License.
+
+8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part
+pre-release, untested, or not fully tested works. The Covered Code may contain
+errors that could cause failures or loss of data, and may be incomplete or
+contain inaccuracies. You expressly acknowledge and agree that use of the
+Covered Code, or any portion thereof, is at Your sole and entire risk. THE
+COVERED CODE IS PROVIDED "AS IS" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF
+ANY KIND AND LICENSOR AND LICENSOR'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS
+"LICENSOR" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY
+DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT
+NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF
+SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET
+ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. LICENSOR AND EACH
+CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE
+COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR
+REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR
+ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR
+WRITTEN DOCUMENTATION, INFORMATION OR ADVICE GIVEN BY LICENSOR, A LICENSOR
+AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You
+acknowledge that the Covered Code is not intended for use in high risk
+activities, including, but not limited to, the design, construction, operation
+or maintenance of nuclear facilities, aircraft navigation, aircraft
+communication systems, or air traffic control machines in which case the failure
+of the Covered Code could lead to death, personal injury, or severe physical or
+environmental damage. Licensor disclaims any express or implied warranty of
+fitness for such uses.
+
+9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT
+SHALL LICENSOR OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL,
+INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR
+YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER
+UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE OR STRICT
+LIABILITY), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF LICENSOR OR SUCH
+CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND
+NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME
+JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR
+CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event
+shall Licensor's total liability to You for all damages (other than as may be
+required by applicable law) under this License exceed the amount of ten dollars
+($10.00).
+
+10. Ownership. Subject to the licenses granted under this License, each
+Contributor retains all rights, title and interest in and to any Modifications
+made by such Contributor. Licensor retains all rights, title and interest in and
+to the Original Code and any Modifications made by or on behalf of Licensor
+("Licensor Modifications"), and such Licensor Modifications will not be
+automatically subject to this License. Licensor may, at its sole discretion,
+choose to license such Licensor Modifications under this License, or on
+different terms from those contained in this License or may choose not to
+license them at all.
+
+11. Termination. 
+
+11.1 Term and Termination. The term of this License is perpetual unless
+terminated as provided below. This License and the rights granted hereunder will
+terminate:
+
+(a) automatically without notice from Licensor if You fail to comply with any
+term(s) of this License and fail to cure such breach within 30 days of becoming
+aware of such breach;
+
+(b) immediately in the event of the circumstances described in Section 12.5(b);
+or
+
+(c) automatically without notice from Licensor if You, at any time during the
+term of this License, commence an action for patent infringement against
+Licensor (including by cross-claim or counter claim in a lawsuit);
+
+(d) upon written notice from Licensor if You, at any time during the term of
+this License, commence an action for patent infringement against any third party
+alleging that the Covered Code itself (excluding combinations with other
+software or hardware) infringes any patent (including by cross-claim or counter
+claim in a lawsuit).
+
+11.2 Effect of Termination. Upon termination, You agree to immediately stop any
+further use, reproduction, modification, sublicensing and distribution of the
+Covered Code and to destroy all copies of the Covered Code that are in your
+possession or control. All sublicenses to the Covered Code which have been
+properly granted prior to termination shall survive any termination of this
+License. Provisions which, by their nature, should remain in effect beyond the
+termination of this License shall survive, including but not limited to Sections
+3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for
+compensation, indemnity or damages of any sort solely as a result of terminating
+this License in accordance with its terms, and termination of this License will
+be without prejudice to any other right or remedy of any party.
+
+12. Miscellaneous.
+
+12.1 Government End Users. The Covered Code is a "commercial item" as defined in
+FAR 2.101. Government software and technical data rights in the Covered Code
+include only those rights customarily provided to the public as defined in this
+License. This customary commercial license in technical data and software is
+provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer
+Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical
+Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software
+or Computer Software Documentation). Accordingly, all U.S. Government End Users
+acquire Covered Code with only those rights set forth herein.
+
+12.2 Relationship of Parties. This License will not be construed as creating an
+agency, partnership, joint venture or any other form of legal association
+between or among You, Licensor or any Contributor, and You will not represent to
+the contrary, whether expressly, by implication, appearance or otherwise.
+
+12.3 Independent Development. Nothing in this License will impair Licensor's
+right to acquire, license, develop, have others develop for it, market and/or
+distribute technology or products that perform the same or similar functions as,
+or otherwise compete with, Modifications, Derivative Works, technology or
+products that You may develop, produce, market or distribute.
+
+12.4 Waiver; Construction. Failure by Licensor or any Contributor to enforce any
+provision of this License will not be deemed a waiver of future enforcement of
+that or any other provision. Any law or regulation which provides that the
+language of a contract shall be construed against the drafter will not apply to
+this License.
+
+12.5 Severability. (a) If for any reason a court of competent jurisdiction finds
+any provision of this License, or portion thereof, to be unenforceable, that
+provision of the License will be enforced to the maximum extent permissible so
+as to effect the economic benefits and intent of the parties, and the remainder
+of this License will continue in full force and effect. (b) Notwithstanding the
+foregoing, if applicable law prohibits or restricts You from fully and/or
+specifically complying with Sections 2 and/or 3 or prevents the enforceability
+of either of those Sections, this License will immediately terminate and You
+must immediately discontinue any use of the Covered Code and destroy all copies
+of it that are in your possession or control.
+
+12.6 Dispute Resolution. Any litigation or other dispute resolution between You
+and Licensor relating to this License shall take place in the Seattle,
+Washington, and You and Licensor hereby consent to the personal jurisdiction of,
+and venue in, the state and federal courts within that District with respect to
+this License. The application of the United Nations Convention on Contracts for
+the International Sale of Goods is expressly excluded.
+
+12.7 Export/Import Laws. This software is subject to all export and import laws
+and restrictions and regulations of the country in which you receive the Covered
+Code and You are solely responsible for ensuring that You do not export,
+re-export or import the Covered Code or any direct product thereof in violation
+of any such restrictions, laws or regulations, or without all necessary
+authorizations.
+
+12.8 Entire Agreement; Governing Law. This License constitutes the entire
+agreement between the parties with respect to the subject matter hereof. This
+License shall be governed by the laws of the United States and the State of
+Washington.
+
+Where You are located in the province of Quebec, Canada, the following clause
+applies: The parties hereby confirm that they have requested that this License
+and all related documents be drafted in English. Les parties ont exig&eacute;
+que le pr&eacute;sent contrat et tous les documents connexes soient
+r&eacute;dig&eacute;s en anglais.
+
+								EXHIBIT A.  
+
+"Copyright &copy; 1995-2002
+RealNetworks, Inc. and/or its licensors. All Rights Reserved.
+
+The contents of this file, and the files included with this file, are subject to
+the current version of the RealNetworks Public Source License Version 1.0 (the
+"RPSL") available at https://www.helixcommunity.org/content/rpsl unless you have
+licensed the file under the RealNetworks Community Source License Version 1.0
+(the "RCSL") available at https://www.helixcommunity.org/content/rcsl, in which
+case the RCSL will apply. You may also obtain the license terms directly from
+RealNetworks. You may not use this file except in compliance with the RPSL or,
+if you have a valid RCSL with RealNetworks applicable to this file, the RCSL.
+Please see the applicable RPSL or RCSL for the rights, obligations and
+limitations governing use of the contents of the file.
+
+This file is part of the Helix DNA Technology. RealNetworks is the developer of
+the Original code and owns the copyrights in the portions it created.
+
+This file, and the files included with this file, is distributed and made
+available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR
+IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING
+WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+
+Contributor(s): ____________________________________ 
+
+Technology Compatibility Kit Test
+Suite(s) Location (if licensed under the RCSL): ______________________________ 
+
+Object Code Notice: Helix DNA Client technology included. Copyright (c)
+RealNetworks, Inc., 1995-2002. All rights reserved.
+
+
+								EXHIBIT B 
+
+Compatible Source Licenses for the RealNetworks Public Source License. The
+following list applies to the most recent version of the license as of October
+25, 2002, unless otherwise indicated.
+
+* Academic Free License
+* Apache Software License
+* Apple Public Source License
+* Artistic license
+* Attribution Assurance Licenses
+* BSD license
+* Common Public License (1)
+* Eiffel Forum License
+* GNU General Public License (GPL) (1)
+* GNU Library or "Lesser" General Public License (LGPL) (1)
+* IBM Public License
+* Intel Open Source License
+* Jabber Open Source License
+* MIT license
+* MITRE Collaborative Virtual Workspace License (CVW License)
+* Motosoto License
+* Mozilla Public License 1.0 (MPL)
+* Mozilla Public License 1.1 (MPL)
+* Nokia Open Source License
+* Open Group Test Suite License
+* Python Software Foundation License
+* Ricoh Source Code Public License
+* Sun Industry Standards Source License (SISSL)
+* Sun Public License
+* University of Illinois/NCSA Open Source License
+* Vovida Software License v. 1.0
+* W3C License
+* X.Net License
+* Zope Public License
+* zlib/libpng license
+
+(1) Note: because this license contains certain reciprocal licensing terms that
+purport to extend to independently developed code, You may be prohibited under
+the terms of this otherwise compatible license from using code licensed under
+its terms with Covered Code because Covered Code may only be licensed under the
+RealNetworks Public Source License. Any attempt to apply non RPSL license terms,
+including without limitation the GPL, to Covered Code is expressly forbidden.
+You are responsible for ensuring that Your use of Compatible Source Licensed
+code does not violate either the RPSL or the Compatible Source License.
+
+The latest version of this list can be found at:
+https://www.helixcommunity.org/content/complicense
+
+								EXHIBIT C 
+
+RealNetworks' Trademark policy.  
+
+RealNetworks defines the following trademarks collectively as "Licensor
+Trademarks": "RealNetworks", "RealPlayer", "RealJukebox", "RealSystem",
+"RealAudio", "RealVideo", "RealOne Player", "RealMedia", "Helix" or any other
+trademarks or trade names belonging to RealNetworks.
+
+RealNetworks "Licensor Trademark Policy" forbids any use of Licensor Trademarks
+except as permitted by and in strict compliance at all times with RealNetworks'
+third party trademark usage guidelines which are posted at
+http://www.realnetworks.com/info/helixlogo.html.
+
Index: helix-libs/clientapps/clutter/Umakefil
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/Umakefil	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,325 @@
+# 
+# ***** BEGIN LICENSE BLOCK ***** 
+# Version: RCSL 1.0/RPSL 1.0 
+#  
+# Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+#      
+# The contents of this file, and the files included with this file, are 
+# subject to the current version of the RealNetworks Public Source License 
+# Version 1.0 (the "RPSL") available at 
+# http://www.helixcommunity.org/content/rpsl unless you have licensed 
+# the file under the RealNetworks Community Source License Version 1.0 
+# (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+# in which case the RCSL will apply. You may also obtain the license terms 
+# directly from RealNetworks.  You may not use this file except in 
+# compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+# applicable to this file, the RCSL.  Please see the applicable RPSL or 
+# RCSL for the rights, obligations and limitations governing use of the 
+# contents of the file.  
+#  
+# This file is part of the Helix DNA Technology. RealNetworks is the 
+# developer of the Original Code and owns the copyrights in the portions 
+# it created. 
+#  
+# This file, and the files included with this file, is distributed and made 
+# available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+# EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+# INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+# FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+# 
+# Technology Compatibility Kit Test Suite(s) Location: 
+#    http://www.helixcommunity.org/content/tck 
+# 
+# Contributor(s): 
+#  
+# ***** END LICENSE BLOCK ***** 
+# 
+
+UmakefileVersion(2,2)
+
+project.AddModuleIncludes("common/include",
+                          "common/runtime/pub",
+                          "client/include",
+                          "client/common/system/pub",
+                          "client/common/container/pub",
+                          "client/audiosvc/pub",
+                          "common/container/pub",
+			  "video/sitelib/pub",
+			  "video/colconverter/pub",
+			  "video/sitelib/pub/platform/unix",
+			  "video/sitelib",
+                          "datatype/rm/include",
+                          "client/core")
+
+project.AddSources("player.cpp",
+                   "excontxt.cpp",
+                   "exsite.cpp",
+                   "exroot.cpp",
+                   "exadvsnk.cpp",
+                   "exerror.cpp",
+                   "iids.cpp",
+                   "exstateadvsnk.cpp",
+                   "excallback.cpp",
+		   "print.cpp")
+
+project.AddModuleLibraries(
+                           "common/runtime[runtlib]",
+                           "common/system[syslib]",
+                           "common/container[contlib]",
+                           "common/runtime[runtlib]",
+                           "client/common/system[sysclntlib]",
+                           "common/dbgtool[debuglib]",
+                           "common/util[utillib]",
+                           "video/sitelib[sitelib]",
+                           "video/sitelib[sitecreatelib]",
+                           "common/log/logutil[logutillib]",
+                           "video/vidutil[vidutillib]"
+                           )
+project.AddSystemLibraries('Xv', 'Xext')
+
+if project.IsDefined("HELIX_FEATURE_PREFERENCES"):
+    project.AddSources("preflist.cpp")
+
+if project.IsDefined("HELIX_FEATURE_AUTHENTICATION"):
+    project.AddSources("exaumgr.cpp")
+
+if project.IsDefined("HELIX_FEATURE_VIDEO"):
+	project.AddSources("exsitsup.cpp",
+                           "fivemmap.cpp")
+	project.AddModuleIncludes('video/include')
+	if project.IsDefined("HELIX_FEATURE_PNG"):
+		project.AddModuleIncludes('datatype/image/png/common/pub')
+		project.AddModuleLibraries("common/import/zlib[zlib]",
+					   "datatype/image/png/import/libpng[libpng]",
+					   "datatype/image/png/common[pngcomlib]")
+
+if project.IsDefined("HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS"):
+	project.AddSources("exprdnld.cpp")
+
+if project.BuildOption("nodll"):
+        ## Client core
+	static_plugin_list = ["clntcore"]
+        project.AddModuleLibraries("common/runtime[runtlib]",
+                                   "common/fileio[fileiolib]",
+                                   "client/common/system[sysclntlib]",
+                                   "client/common/container[contclntlib]",
+                                   "client/core[clntcorelib]")
+        if not project.IsDefined("HELIX_FEATURE_LOGLEVEL_NONE"):
+            project.AddModuleLibraries("common/log/logutil[logutillib]")
+        if not project.IsDefined("HELIX_CONFIG_MINIMIZE_SIZE"):
+            project.AddModuleLibraries("client/common/util[utlclntlib]")
+        ## Client core libraries
+        if project.IsDefined("HELIX_FEATURE_AUDIO"):
+        	project.AddModuleLibraries("audio/device[auddevlib]",
+	        			   "client/audiosvc[audsvclib]")
+	if ('HELIX_FEATURE_VOLUME' in project.defines):
+		project.AddModuleLibraries("audio/gaintool[audgainlib]" )
+	if ('HELIX_FEATURE_VOLUME' in project.defines):
+		project.AddModuleLibraries("audio/crossfade[audxfadelib]")
+        if project.IsDefined("HELIX_FEATURE_MIXER"):
+        	project.AddModuleLibraries("audio/mixer[audmixlib]")
+        if project.IsDefined("HELIX_FEATURE_RESAMPLER"):
+        	project.AddModuleLibraries("audio/resampler[audresamplib]")
+        if project.IsDefined("HELIX_FEATURE_LIMITER"):
+        	project.AddModuleLibraries("audio/limiter[audlimiter]")
+
+        if project.IsDefined("HELIX_FEATURE_VIDEO"):
+        	project.AddModuleLibraries("client/videosvc[vidsvclib]",
+                                           "protocol/sdp[sdplib]")
+        if project.IsDefined("HELIX_FEATURE_PLAYBACK_NET"):
+        	project.AddModuleLibraries("client/netwksvc[netsvclib]",
+                                           "common/netio[netiolib]",
+        				   "client/common/netio[netioclntlib]",
+        				   "protocol/transport/common/system[systranlib]",
+        				   "protocol/transport/rtp[rtptranlib]",
+        				   "protocol/common/util[protutillib]",
+        				   "protocol/rtsp[rtsplib]")
+        if project.IsDefined("HELIX_FEATURE_RDT"):
+		project.AddLibraries(GetSDKPath("prtclrdt_lib"))
+            	project.AddModuleLibraries("protocol/transport/rdt[rdttranlib]")
+        if project.IsDefined("HELIX_FEATURE_PNA"):
+		project.AddLibraries(GetSDKPath("prtclpna_lib"))
+        if project.IsDefined("HELIX_FEATURE_XMLPARSER"):
+        	project.AddModuleLibraries("common/lang/xml[xmllib]")
+        ## Add RAM file format and renderer
+	if project.IsDefined("HELIX_FEATURE_META"):
+		static_plugin_list[-1:-1] = ["ramfformat", "ramrender"]
+                project.AddModuleLibraries("datatype/ram/renderer[ramrendrlib]")
+        ## Add local file system
+	if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL"):
+		static_plugin_list[-1:-1] = ["smplfsys"]
+                project.AddModuleLibraries("common/fileio[fileiolib]")
+        ## Add http file system
+	if project.IsDefined("HELIX_FEATURE_PLAYBACK_NET"):
+		static_plugin_list[-1:-1] = ["hxsdp", "httpfsys"]
+                project.AddModuleLibraries("protocol/http[httplib]",
+                                           "protocol/common/util[protutillib]",
+                                           "protocol/sdp[sdplib]",
+                                           "filesystem/data[datafsys]",
+                                           "common/fileio[fileiolib]",
+                                           "common/import/zlib[zlib]")
+        ## Add realmedia file format
+	if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL") and \
+	    (project.IsDefined("HELIX_FEATURE_AUDIO_REAL") or    \
+             project.IsDefined("HELIX_FEATURE_VIDEO_REAL")):
+		static_plugin_list[-1:-1] = ["rmfformat"]
+                project.AddModuleLibraries("datatype/common/util[dtutillib]",
+                                           "datatype/common/container[dtcomcontlib]")
+		project.AddLibraries(GetSDKPath("rmcom_lib"),
+                                     GetSDKPath("rmacom_lib"),
+                                     GetSDKPath("rmff_lib"),
+			             GetSDKPath("rmvidpyld_lib"))
+
+        ## Add realmedia renderer
+	if project.IsDefined("HELIX_FEATURE_AUDIO_REAL"):
+		static_plugin_list[-1:-1] = ["rarender"]
+                project.AddModuleLibraries("datatype/rm/audio/payload[rapayld]")
+                project.AddLibraries(GetSDKPath("rmarend_lib"),
+                                     GetSDKPath("rmacom_lib"))
+        ## Add mp3 file format and renderer
+	if project.IsDefined("HELIX_FEATURE_AUDIO_MPA_LAYER3") or \
+           project.IsDefined("HELIX_FEATURE_AUDIO_MPA_LAYER2") or \
+           project.IsDefined("HELIX_FEATURE_AUDIO_MPA_LAYER1"):
+		static_plugin_list[-1:-1] = ["mp3render"]
+                project.AddModuleLibraries("datatype/mp3/codec/fltpt[mp3codecfltpt]",
+                                           "datatype/mp3/common[mp3lib]",
+                                           "datatype/mp3/payload[mp3payld]",
+                                           "datatype/common/util[dtutillib]")
+		if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL"):
+			static_plugin_list[-1:-1] = ["mp3fformat"]
+                        project.AddModuleLibraries("datatype/mp3/common[mp3lib]")
+        ## Add gecko realmedia codec
+	if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_GECKO"):
+		static_plugin_list[-1:-1] = ["cook"]
+		if not project.IsDefined("HELIX_CONFIG_FIXEDPOINT"):
+			project.AddLibraries(GetSDKPath("ra8lbrdec_flt_lib"))
+		else:
+			project.AddLibraries(GetSDKPath("ra8lbrdec_fix_lib"))
+                project.AddModuleLibraries("datatype/rm/audio/codec/common[racompat]")
+        ## Add RAAC codec
+	if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_RAAC"):
+		static_plugin_list[-1:-1] = ["raac"]
+		project.AddModuleLibraries("datatype/mp4/common[mp4comlib]",
+                                           "datatype/aac/codec/fixpt/decoder/hxwrap[aacdeclib]")
+        ## Add sipro realmedia codec
+        ## (Right now this only works for floating-point platforms)
+	if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_SIPRO"):
+		static_plugin_list[-1:-1] = ["sipr"]
+		project.AddLibraries(GetSDKPath("sipro_flt_backend_lib"))
+        ## Add tokyo realmedia codec
+	if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_TOKYO"):
+		static_plugin_list[-1:-1] = ["atrc"]
+		project.AddLibraries(GetSDKPath("ra8hbr_lib"))
+        ##
+	if project.IsDefined("HELIX_FEATURE_VIDEO"):
+		static_plugin_list[-1:-1] = ["vidsite"]
+		static_plugin_list[-1:-1] = ["hxltcolor"]
+                project.AddModuleLibraries("datatype/common/vidrend[vidrend]",
+                                           "video/sitelib[sitelib]",
+                                           "video/site[vidsite]",
+                                           "video/colconverter[hxltcolor]",
+                                           "datatype/rm/common[rmcomlib]",
+                                           "video/vidutil[vidutillib]")
+
+		if (project.IsDefined('HELIX_FEATURE_ALTERNATE_SITE_CREATE_LIB')):
+                    project.AddLibraries(GetSDKPath("sitecreate_lib"))
+                else:
+                    project.AddModuleLibraries('video/sitelib[sitecreatelib]')
+                
+        ## Add realvideo renderer
+	if project.IsDefined("HELIX_FEATURE_VIDEO_REAL"):
+		project.AddModuleLibraries("datatype/rm/video/renderer[rvxrendlib]")
+		project.AddLibraries(GetSDKPath("rmvidcom_lib"),
+                                     GetSDKPath("rmvidpyld_lib"),
+                                     GetSDKPath("rvcodcom_lib"))
+                project.AddModuleLibraries("datatype/common/util[dtutillib]")
+		static_plugin_list[-1:-1] = ["rvrender"]
+                
+        ## Add mpeg4 file format
+	if project.IsDefined("HELIX_FEATURE_PLAYBACK_LOCAL")and \
+	   (project.IsDefined("HELIX_FEATURE_VIDEO_H263") or    \
+            project.IsDefined("HELIX_FEATURE_VIDEO_MPEG4") or   \
+            project.IsDefined("HELIX_FEATURE_AUDIO_MPEG4")):
+		static_plugin_list[-1:-1] = ["mp4fformat"]
+                project.AddModuleLibraries("datatype/common/util[dtutillib]",
+                                           "datatype/common/audrend",
+                                           "datatype/mp4/common[mp4comlib]",
+                                           "datatype/mp4/payload[mp4pyldlib]",
+                                           "datatype/mp4/fileformat[mp4fformatlib]")
+                if not project.IsDefined("HELIX_FEATURE_MP4_FILEFORMAT_M4A_ONLY"):
+                    project.AddModuleLibraries("protocol/sdp[sdplib]",
+                                               "protocol/rtsp[rtsplib]",
+                                               "protocol/common/util[protutillib]",
+                                               "datatype/rm/common[rmcomlib]",
+                                               "datatype/amr/common[amrcomlib]")
+        ## Add h.263 renderer
+	if project.IsDefined("HELIX_FEATURE_VIDEO_H263"):
+		project.AddModuleLibraries("datatype/h263/payload[h263pyldlib]")
+		static_plugin_list[-1:-1] = ["h263render"]
+        ## Add MPEG4 renderer
+#	if project.IsDefined("HELIX_FEATURE_VIDEO_MPEG4"):
+#		static_plugin_list[-1:-1] = ["mp4xrender"]
+        ## Add mpeg 4 audio renderer
+	if project.IsDefined("HELIX_FEATURE_AUDIO_MPEG4"):
+		static_plugin_list[-1:-1] = ["mp4arender"]
+		project.AddModuleLibraries("datatype/mp4/audio/renderer[mp4arenderlib]")
+                if not project.IsDefined("HELIX_FEATURE_MP4_FILEFORMAT_M4A_ONLY"):
+                    project.AddModuleLibraries("datatype/amr/common[amrcomlib]")
+        ## Add RV10 codec
+        if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV10"):
+            project.AddLibraries(GetSDKPath("rv1dec_libs")+"[rv10lib]",
+                                 GetSDKPath("rv1dec_libs")+"[drv1lib]")
+            static_plugin_list[-1:-1] = ["rv10", "drv1"]
+        ## Add RV20 codec
+	if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV20"):
+		project.AddLibraries(GetSDKPath("rvg2dec_libs")+"[rv20lib]",
+                                     GetSDKPath("rvg2dec_libs")+"[drv2lib]")
+		static_plugin_list[-1:-1] = ["rv20", "drv2"]
+
+	if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV30") or \
+	   project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV40"):
+		static_plugin_list[-1:-1] = ["drvc"]
+		if project.IsDefined("HELIX_FEATURE_ANSIC_RV89COMBO"):
+			project.AddLibraries(GetSDKPath("rv89combo_c_libs")+"[drvc]")
+		else:
+			project.AddLibraries(GetSDKPath("rv89combo_libs")+"[drvclib]")
+
+	if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV30"):
+		static_plugin_list[-1:-1] = ["rv30"]
+		project.AddLibraries(GetSDKPath("rv89combo_libs")+"[rv3xlib]")
+                project.AddModuleLibraries("datatype/rm/video/codec/rv89combo[rv30]")
+
+	if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV40"):
+		static_plugin_list[-1:-1] = ["rv40"]
+		project.AddLibraries(GetSDKPath("rv89combo_libs")+"[rv4xlib]")
+                project.AddModuleLibraries("datatype/rm/video/codec/rv89combo[rv40]")
+
+#	if project.IsDefined("HELIX_FEATURE_AUDIO_CODEC_AAC"):
+#		static_plugin_list[-1:-1] = ["aac4"]
+
+	CreateStaticPluginTable(static_plugin_list)
+
+project.ExportFunction("init_main", "void")
+project.ExportFunction("deinit_main", "void")
+project.ExportFunction("get_player", "void **ppPlayer",
+                    "on_buffering_cb_t on_buffering_cb",
+                    "on_pos_length_cb_t on_pos_length_cb")
+project.ExportFunction("player_openurl", "void *pPlayerHandle",
+                    "char *pszRawURL")
+project.ExportFunction("put_player", "void *pPlayerHandle")
+project.ExportFunction("player_geturl", "void *pPlayerHandle", "char **pszURL")
+project.ExportFunction("player_begin", "void *pPlayerHandle")
+project.ExportFunction("player_stop", "void *pPlayerHandle")
+project.ExportFunction("player_pause", "void *pPlayerHandle")
+project.ExportFunction("player_seek", "void *pPlayerHandle", "int pos")
+project.ExportFunction("get_curr_playtime", "void *pPlayerHandle")
+project.ExportFunction("player_getvolume", "void *pPlayerHandle")
+project.ExportFunction("player_canseek", "void *pPlayerHandle")
+project.ExportFunction("player_setvolume", "void *pPlayerHandle", "unsigned short volumn")
+
+
+
+DLLTarget('libhelix-player')
+
+DependTarget()
+
Index: helix-libs/clientapps/clutter/exabd.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exabd.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,245 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include <stdio.h>
+
+#include "hxtypes.h"
+
+#include "hxcom.h"
+#include "hxcomm.h"
+#include "hxmon.h"
+#include "hxcore.h"
+#include "hxengin.h"
+#include "chxpckts.h"
+#include "hxclsnk.h"
+#include "hxstrutl.h"
+#include "exabd.h"
+
+#include "print.h"
+
+#include "globals.h"
+
+struct _stGlobals*& GetGlobal(); //in main.cpp
+
+ExampleABD::ExampleABD(IUnknown* pUnknown)
+           : m_lRefCount (0)
+           , m_pUnknown (NULL)
+           , m_ulABDStartTime(0)
+           , m_ulABDResult(0)
+           , m_bABDDone(FALSE)
+{
+    if (pUnknown)
+    {
+	m_pUnknown = pUnknown;
+	m_pUnknown->AddRef();
+    }
+}
+
+ExampleABD::~ExampleABD(void)
+{
+    HX_RELEASE(m_pUnknown);
+}
+
+
+// *** IUnknown methods ***
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::QueryInterface
+//  Purpose:
+//	Implement this to export the interfaces supported by your 
+//	object.
+//
+STDMETHODIMP ExampleABD::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IUnknown))
+    {
+	AddRef();
+	*ppvObj = (IUnknown*)(IHXAutoBWCalibrationAdviseSink*)this;
+	return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXAutoBWCalibrationAdviseSink))
+    {
+	AddRef();
+	*ppvObj = (IHXAutoBWCalibrationAdviseSink*)this;
+	return HXR_OK;
+    }
+
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::AddRef
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleABD::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::Release
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleABD::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+/*
+ *	IHXAutoBWCalibrationAdviseSink methods
+ */
+STDMETHODIMP
+ExampleABD::AutoBWCalibrationStarted (const char* pszServer)
+{
+    if (pszServer)
+    {
+        STDOUT("ABD: contacting %s\n", pszServer);        
+    }
+
+    return HXR_OK;
+}
+
+STDMETHODIMP
+ExampleABD::AutoBWCalibrationDone(HX_RESULT  status,
+                                  UINT32     ulBW)
+{
+    m_bABDDone = TRUE;
+
+    if (HXR_OK == status)
+    {
+        m_ulABDResult = ulBW;
+        STDOUT("ABD: %lu(Kbps) %lu(ms)\n", ulBW, GetTickCount() - m_ulABDStartTime);        
+    }
+    else
+    {
+        STDOUT("ABD failed: %lu\n", status);        
+    }
+
+    return HXR_OK;
+}
+
+HX_RESULT
+ExampleABD::DoABD(const char*   pszServer,
+                  UINT32        mode,
+                  UINT32        packetSize,
+                  UINT32        packetNum)
+{
+    HX_RESULT               rc = HXR_OK;
+    UINT32                  length = 0;
+    IHXAutoBWCalibration*   pABD = NULL;
+    IHXValues*              pValues = NULL;
+    IHXBuffer*              pBuffer = NULL;
+
+    m_ulABDStartTime = GetTickCount();
+    m_ulABDResult = 0;
+    m_bABDDone = FALSE;
+
+    if (m_pUnknown &&
+        HXR_OK == m_pUnknown->QueryInterface(IID_IHXAutoBWCalibration, (void**)&pABD))
+    {
+        pValues = (IHXValues*) new CHXHeader();
+        pValues->AddRef();
+
+	pBuffer = (IHXBuffer*) new CHXBuffer();
+	pBuffer->AddRef();
+
+	pBuffer->Set((UCHAR*)pszServer, strlen(pszServer)+1);        
+        pValues->SetPropertyCString("ABDServers", pBuffer);
+
+        pValues->SetPropertyULONG32("AutoBWDetectionMode", mode);
+        pValues->SetPropertyULONG32("AutoBWDetectionPacketSize", packetSize);
+        pValues->SetPropertyULONG32("AutoBWDetectionPackets", packetNum);       
+
+        pABD->AddAutoBWCalibrationSink((IHXAutoBWCalibrationAdviseSink*)this);
+        pABD->InitAutoBWCalibration(pValues);
+
+        pABD->StartAutoBWCalibration();
+
+        while (!m_bABDDone)
+        {
+            MSG msg;
+            DWORD starttime, endtime, i;
+            BOOL sleep = TRUE;
+            static const int checkinterval = 10;
+
+            starttime = GetTickCount();
+            endtime = starttime + (20);
+            i = 0;
+            while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+            {
+                DispatchMessage(&msg);
+                if ((i % checkinterval) == 0)
+                {
+                    if (GetTickCount() > endtime)
+                        break;
+                    ++i;
+                }
+                sleep = FALSE;
+            }
+
+            if (sleep)
+                Sleep(10);
+        }
+    }
+
+cleanup:
+
+    if (pABD)
+    {
+        pABD->RemoveAutoBWCalibrationSink((IHXAutoBWCalibrationAdviseSink*)this);
+    }
+
+    HX_RELEASE(pBuffer);
+    HX_RELEASE(pValues);
+    HX_RELEASE(pABD);
+
+    return rc;
+}
+
+
Index: helix-libs/clientapps/clutter/exabd.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exabd.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,85 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXAMPLEABD_
+#define _EXAMPLEABD_
+
+struct IHXAutoBWCalibrationAdviseSink;
+struct IUnknown;
+
+class ExampleABD : public IHXAutoBWCalibrationAdviseSink
+{
+  private:
+    LONG32          m_lRefCount;    
+    IUnknown*       m_pUnknown;    
+    UINT32          m_ulABDStartTime;
+    UINT32          m_ulABDResult;
+    BOOL            m_bABDDone;
+    
+    ~ExampleABD();
+
+  public:
+
+    ExampleABD(IUnknown* /*IN*/ pUnknown);
+
+    /*
+     *  IUnknown methods
+     */
+    STDMETHOD(QueryInterface) (THIS_
+                               REFIID riid,
+                               void** ppvObj);
+    
+    STDMETHOD_(ULONG32,AddRef) (THIS);
+
+    STDMETHOD_(ULONG32,Release) (THIS);
+
+    /*
+     *	IHXAutoBWCalibrationAdviseSink methods
+     */
+    STDMETHOD(AutoBWCalibrationStarted) (THIS_
+                                         const char* pszServer);
+    STDMETHOD(AutoBWCalibrationDone)	(THIS_
+                                         HX_RESULT  status,
+                                         UINT32     ulBW);
+
+    HX_RESULT   DoABD(const char*   pszServer,
+                      UINT32        mode,
+                      UINT32        packetSize,
+                      UINT32        packetNum);
+
+    UINT32      GetABD(void) { return m_ulABDResult; };
+};
+
+#endif /* _EXAMPLEABDSNK_ */
Index: helix-libs/clientapps/clutter/exadvsnk.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exadvsnk.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,1116 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include <stdio.h>
+
+#include "hxtypes.h"
+
+#include "hxcom.h"
+#include "hxcomm.h"
+#include "hxmon.h"
+#include "hxcore.h"
+#include "hxengin.h"
+#include "hxclsnk.h"
+#include "hxgroup.h"
+#include "hxstrutl.h"
+#include "exadvsnk.h"
+#include "hxstring.h"
+#include "hxprefs.h"
+#include "excontxt.h"
+
+#include "print.h"
+
+#include "globals.h"
+#include "player.h"
+
+struct _stGlobals*& GetGlobal(); //in main.cpp
+
+#ifdef __TCS__
+extern unsigned long   gStreamTime;
+ 
+static int		iOpened = 0;
+
+
+#if	defined(__cplusplus)
+extern	"C"	{
+#endif	/* defined(__cplusplus) */
+
+typedef enum hookBuffering {
+	eContacting = 0,
+	eConnecting = 1,
+	eBuffering = 2,
+	ePlaying = 3
+}hookBuffering;
+
+void hookRealAudio_Buffering(hookBuffering connectState, int pct);
+
+void hookRealAudio_PlayPosition(unsigned long current,unsigned long duration);
+
+typedef enum hookState {
+	ePlay = 0,
+	ePause = 1,
+	eStop = 2,
+	eResume = 3,
+	eComplete				// Clip is done playing
+}hookState;
+void hookRealAudio_State(hookState newState);
+
+
+#if	defined(__cplusplus)
+}
+#endif	/* defined(__cplusplus) */
+
+#endif // __TCS__
+
+void PrintBuffer(const char* pszName,const unsigned char* pbBuf, unsigned int dwBytes);
+
+ExampleClientAdviceSink::ExampleClientAdviceSink(IUnknown* pUnknown, LONG32 lClientIndex, on_buffering_cb_t on_buffering_cb, on_pos_length_cb_t on_pos_length_cb, void *context)
+    : m_lRefCount (0)
+    , m_lClientIndex (lClientIndex)
+    , m_pUnknown (NULL)
+    , m_pRegistry (NULL)
+    , m_pScheduler (NULL)
+    , m_lCurrentBandwidth(0)
+    , m_lAverageBandwidth(0)
+    , m_bOnStop(0)
+	, m_pPlayer(0)
+    , m_bWaitForTrackStart(0)
+    , m_on_buffering_cb(on_buffering_cb)
+    , m_on_pos_length_cb(on_pos_length_cb)
+    , m_context(context)
+{
+    if (pUnknown)
+    {
+	m_pUnknown = pUnknown;
+	m_pUnknown->AddRef();
+
+	if (HXR_OK != m_pUnknown->QueryInterface(IID_IHXRegistry, (void**)&m_pRegistry))
+	{
+	    m_pRegistry = NULL;
+	}
+
+	if (HXR_OK != m_pUnknown->QueryInterface(IID_IHXScheduler, (void**)&m_pScheduler))
+	{
+	    m_pScheduler = NULL;
+	}
+
+	IHXPlayer* pPlayer;
+	if(HXR_OK == m_pUnknown->QueryInterface(IID_IHXPlayer,
+						(void**)&pPlayer))
+	{
+		m_pPlayer = pPlayer;
+
+            IHXGroupManager* pGroupMgr = NULL;
+            if(HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager,
+                                                   (void**)&pGroupMgr))
+            {
+                pGroupMgr->AddSink((IHXGroupSink*)this);
+                pGroupMgr->Release();
+            }
+
+	    pPlayer->AddAdviseSink(this);
+
+	}
+    }
+
+#ifdef __TCS__
+    bEnableAdviceSink = TRUE;
+    iOpened = 0;
+#endif 
+}
+
+ExampleClientAdviceSink::~ExampleClientAdviceSink(void)
+{
+    if (m_pScheduler)
+    {
+        m_pScheduler->Release();
+        m_pScheduler = NULL;
+    }
+
+    if (m_pRegistry)
+    {
+	m_pRegistry->Release();
+	m_pRegistry = NULL;
+    }
+
+    if (m_pPlayer)
+    {
+	m_pPlayer->Release();
+	m_pPlayer = NULL;
+    }
+    if (m_pUnknown)
+    {
+	m_pUnknown->Release();
+	m_pUnknown = NULL;
+    }
+}
+
+
+// *** IUnknown methods ***
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::QueryInterface
+//  Purpose:
+//	Implement this to export the interfaces supported by your 
+//	object.
+//
+STDMETHODIMP ExampleClientAdviceSink::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IUnknown))
+    {
+	AddRef();
+	*ppvObj = (IUnknown*)(IHXClientAdviseSink*)this;
+	return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXClientAdviseSink))
+    {
+	AddRef();
+	*ppvObj = (IHXClientAdviseSink*)this;
+	return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXGroupSink))
+    {
+	AddRef();
+	*ppvObj = (IHXGroupSink*)this;
+	return HXR_OK;
+    }
+
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::AddRef
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleClientAdviceSink::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::Release
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleClientAdviceSink::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+/*
+ *	IHXClientAdviseSink methods
+ */
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnPosLength
+ *	Purpose:
+ *	    Called to advise the client that the position or length of the
+ *	    current playback context has changed.
+ */
+
+#ifdef __TCS__
+static long	lastPosition = -1;
+#endif
+
+STDMETHODIMP
+ExampleClientAdviceSink::OnPosLength(UINT32	  ulPosition,
+				   UINT32	  ulLength)
+{
+    // Are we doing a multi-seek?
+    if (GetGlobal()->g_bMultiSeek)
+    {
+        // Have we run out of seek times?
+        if (GetGlobal()->g_ulMultiSeekIndex < GetGlobal()->g_ulNumMultiSeeks)
+        {
+            STDOUT("Multi-seeking the first player to %lu\n",
+                   GetGlobal()->g_ulMultiSeekTime[GetGlobal()->g_ulMultiSeekIndex]);
+            GetGlobal()->g_Players[0]->Seek(GetGlobal()->g_ulMultiSeekTime[GetGlobal()->g_ulMultiSeekIndex++]);
+        }
+        else
+        {
+            // We've run out - stop the multi-seek
+            GetGlobal()->g_bMultiSeek       = FALSE;
+            GetGlobal()->g_ulNumMultiSeeks  = 0;
+            GetGlobal()->g_ulMultiSeekIndex = 0;
+        }
+    }
+
+    if (m_on_pos_length_cb)
+        m_on_pos_length_cb(ulPosition, ulLength, m_context);
+
+    return HXR_OK;
+}
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnPresentationOpened
+ *	Purpose:
+ *	    Called to advise the client a presentation has been opened.
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnPresentationOpened()
+{
+#ifdef __TCS__
+    iOpened = 1;
+    lastPosition = -1;
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnPresentationOpened()\n");
+    }
+#if defined(HELIX_FEATURE_PLAYBACK_VELOCITY)
+    // Try to get the IHXPlaybackVelocity interface
+    // from the first player
+    if (GetGlobal()->g_nPlayers > 0 && GetGlobal()->g_Players[0])
+    {
+        IHXPlaybackVelocity* pVel = NULL;
+        HX_RESULT rv = GetGlobal()->g_Players[0]->QueryInterface(IID_IHXPlaybackVelocity, (void**) &pVel);
+        if (SUCCEEDED(rv))
+        {
+            // Get the capabilities object from the player
+            rv = pVel->QueryVelocityCaps(GetGlobal()->g_pVelocityCaps);
+            if (SUCCEEDED(rv) && GetGlobal()->bEnableAdviceSink)
+            {
+                STDOUT("Available Velocity Ranges:");
+                UINT32 ulNumRanges = GetGlobal()->g_pVelocityCaps->GetNumRanges();
+                for (UINT32 i = 0; i < ulNumRanges && SUCCEEDED(rv); i++)
+                {
+                    INT32 lMin = 0;
+                    INT32 lMax = 0;
+                    rv = GetGlobal()->g_pVelocityCaps->GetRange(i, lMin, lMax);
+                    if (SUCCEEDED(rv))
+                    {
+                        STDOUT(" [%ld,%ld]", lMin, lMax);
+                    }
+                }
+                STDOUT("\n");
+            }
+        }
+        HX_RELEASE(pVel);
+    }
+#endif /* #if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) */
+#endif
+
+    UINT32 sourceCount = m_pPlayer->GetSourceCount();	
+    for (UINT32 sourceID = 0; sourceID < sourceCount; sourceID ++)
+    {
+	// get HXSource
+        IUnknown* pUnkSource = NULL;
+        IHXStreamSource* pStreamSrc = NULL;
+
+        if (HXR_OK != m_pPlayer->GetSource (sourceID, pUnkSource))
+        {
+            continue;
+        }
+
+        pUnkSource->QueryInterface(IID_IHXStreamSource, (void **)&pStreamSrc);
+
+        HX_RELEASE(pUnkSource);
+
+        if (!pStreamSrc)
+        {
+            continue;
+        }
+
+        UINT32 num_streams = pStreamSrc->GetStreamCount();
+
+        // get information from Streams
+        for (UINT32 streamID = 0; streamID < num_streams ; streamID++)
+        {
+            IUnknown* pUnkStream = NULL;
+
+            if (HXR_OK == pStreamSrc->GetStream(streamID, pUnkStream))
+            {
+                IHXStream* pStream = NULL;
+
+                if (HXR_OK == pUnkStream->QueryInterface(IID_IHXStream,
+                                                         (void**)&pStream))
+                {
+                    const char* pMimeType = pStream->GetStreamType();
+                    if( 0 == strcmp(pMimeType, "application/ram"))
+                    {
+		        m_bWaitForTrackStart = TRUE;
+                    }
+                    else
+               	    {
+                        m_bWaitForTrackStart = FALSE;
+                    }
+                }
+                HX_RELEASE(pStream);
+            }
+            HX_RELEASE(pUnkStream);
+            if (!m_bWaitForTrackStart)
+            {
+                break;
+            }
+        }
+
+        if (!m_bWaitForTrackStart)
+        {
+            break;
+        }
+        HX_RELEASE(pStreamSrc);
+    }
+
+    if (!m_bWaitForTrackStart)
+    {
+	STDOUT("----------------clip info--------------------\n");
+	if(m_pScheduler)	{
+		m_hCallback = m_pScheduler->RelativeEnter(this,50);
+	}
+    }
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnPresentationClosed
+ *	Purpose:
+ *	    Called to advise the client a presentation has been closed.
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnPresentationClosed()
+{
+#ifdef __TCS__
+    iOpened = 0;
+    lastPosition = -1;
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnPresentationClosed()\n");
+    }
+#endif
+
+    return HXR_OK;
+}
+
+void ExampleClientAdviceSink::GetStatistics (char* pszRegistryKey)
+{
+    char    szRegistryValue[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
+    INT32   lValue = 0;
+    INT32   i = 0;
+    INT32   lStatistics = 8;
+    UINT32 *plValue;
+    
+#ifdef __TCS__    
+    return;	  // DISABLED FOR NOW
+#endif
+
+    // collect statistic
+    for (i = 0; i < lStatistics; i++)
+    {
+	plValue = NULL;
+	switch (i)
+	{
+	case 0:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Normal", pszRegistryKey);
+	    break;
+	case 1:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Recovered", pszRegistryKey);
+	    break;
+	case 2:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Received", pszRegistryKey);
+	    break;
+	case 3:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Lost", pszRegistryKey);
+	    break;
+	case 4:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.Late", pszRegistryKey);
+	    break;
+	case 5:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.ClipBandwidth", pszRegistryKey);
+	    break;
+	case 6:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.AverageBandwidth", pszRegistryKey);
+	    plValue = &m_lAverageBandwidth;
+	    break;
+	case 7:
+	    SafeSprintf(szRegistryValue, MAX_DISPLAY_NAME, "%s.CurrentBandwidth", pszRegistryKey);
+	    plValue = &m_lCurrentBandwidth;
+	    break;
+	default:
+	    break;
+	}
+
+	m_pRegistry->GetIntByName(szRegistryValue, lValue);
+	if (plValue)
+	{
+	    if (m_bOnStop || lValue == 0)
+	    {
+		lValue = *plValue;
+	    }
+	    else
+	    {
+		*plValue = lValue;
+	    }
+	}
+	if (GetGlobal()->bEnableAdviceSink || (GetGlobal()->bEnableVerboseMode && m_bOnStop))
+	{
+	    STDOUT("%s = %ld\n", szRegistryValue, lValue);
+	}
+    }
+}
+
+void ExampleClientAdviceSink::GetAllStatistics(void)
+{
+    UINT32  unPlayerIndex = 0;
+    UINT32  unSourceIndex = 0;
+    UINT32  unStreamIndex = 0;
+
+    char*   pszRegistryPrefix = "Statistics";
+    char    szRegistryName[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
+
+#ifdef __TCS__    
+    return;	  // DISABLED FOR NOW
+#endif
+    
+    // display the content of whole statistic registry
+    if (m_pRegistry)
+    {
+	// ok, let's start from the top (player)
+	SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld", pszRegistryPrefix, m_lClientIndex);
+	if (PT_COMPOSITE == m_pRegistry->GetTypeByName(szRegistryName))
+	{
+	    // display player statistic
+	    GetStatistics(szRegistryName);
+
+	    SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Source%ld", szRegistryName, unSourceIndex);
+	    while (PT_COMPOSITE == m_pRegistry->GetTypeByName(szRegistryName))
+	    {
+		// display source statistic
+		GetStatistics(szRegistryName);
+
+		SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Stream%ld", szRegistryName, unStreamIndex);
+		while (PT_COMPOSITE == m_pRegistry->GetTypeByName(szRegistryName))
+		{
+		    // display stream statistic
+		    GetStatistics(szRegistryName);
+
+		    unStreamIndex++;
+
+		    SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld.Source%ld.Stream%ld", 
+			pszRegistryPrefix, unPlayerIndex, unSourceIndex, unStreamIndex);
+		}
+
+		unSourceIndex++;
+
+		SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld.Source%ld",
+		    pszRegistryPrefix, unPlayerIndex, unSourceIndex);
+	    }
+
+	    unPlayerIndex++;
+
+	    SafeSprintf(szRegistryName, MAX_DISPLAY_NAME, "%s.Player%ld", pszRegistryPrefix, unPlayerIndex);
+	}
+    }
+}
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnStatisticsChanged
+ *	Purpose:
+ *	    Called to advise the client that the presentation statistics
+ *	    have changed. 
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnStatisticsChanged(void)
+{
+    char        szBuff[1024]; /* Flawfinder: ignore */
+    HX_RESULT   res     = HXR_OK;
+    UINT16      uPlayer = 0;
+
+#ifdef __TCS__    
+    return HXR_OK;	  // DISABLED FOR NOW
+#endif
+
+    if(GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnStatisticsChanged():\n");
+
+        SafeSprintf(szBuff, 1024, "Statistics");        
+        res = DumpRegTree( szBuff );
+    }
+
+    return HXR_OK;
+}
+
+HX_RESULT ExampleClientAdviceSink::DumpRegTree(const char* pszTreeName )
+{
+    const char* pszName = NULL;
+    ULONG32     ulRegID   = 0;
+    HX_RESULT   res     = HXR_OK;
+    INT32       nVal    = 0;
+    IHXBuffer* pBuff   = NULL;
+    IHXValues* pValues = NULL;
+
+    //See if the name exists in the reg tree.
+    res = m_pRegistry->GetPropListByName( pszTreeName, pValues);
+    if( HXR_OK!=res || !pValues )
+        return HXR_FAIL;
+
+    //make sure this is a PT_COMPOSITE type reg entry.
+    if( PT_COMPOSITE != m_pRegistry->GetTypeByName(pszTreeName))
+        return HXR_FAIL;
+
+    //Print out the value of each member of this tree.
+    res = pValues->GetFirstPropertyULONG32( pszName, ulRegID );
+    while( HXR_OK == res )
+    {
+        //We have at least one entry. See what type it is.
+        HXPropType pt = m_pRegistry->GetTypeById(ulRegID);
+        switch(pt)
+        {
+           case PT_COMPOSITE:
+               DumpRegTree(pszName);
+               break;
+           case PT_INTEGER :
+               nVal = 0;
+               m_pRegistry->GetIntById( ulRegID, nVal );
+               STDOUT("%s : %d\n", pszName, nVal ); 
+               break;
+           case PT_INTREF :
+               nVal = 0;
+               m_pRegistry->GetIntById( ulRegID, nVal );
+               STDOUT("%s : %d\n", pszName, nVal ); 
+               break;
+           case PT_STRING :
+               pBuff = NULL;
+               m_pRegistry->GetStrById( ulRegID, pBuff );
+               STDOUT("%s : \"", pszName ); 
+               if( pBuff )
+                   STDOUT("%s", (const char *)(pBuff->GetBuffer()) );
+               STDOUT("\"\n" ); 
+               HX_RELEASE(pBuff);
+               break;
+           case PT_BUFFER :
+               STDOUT("%s : BUFFER TYPE NOT SHOWN\n",
+                        pszName, nVal ); 
+               break;
+           case PT_UNKNOWN:
+               STDOUT("%s Unkown registry type entry\n", pszName );
+               break;
+           default:
+               STDOUT("%s Unkown registry type entry\n", pszName );
+               break;
+        }
+        res = pValues->GetNextPropertyULONG32( pszName, ulRegID);
+    }
+
+    HX_RELEASE( pValues );
+    
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnPreSeek
+ *	Purpose:
+ *	    Called by client engine to inform the client that a seek is
+ *	    about to occur. The render is informed the last time for the 
+ *	    stream's time line before the seek, as well as the first new
+ *	    time for the stream's time line after the seek will be completed.
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnPreSeek(	ULONG32	ulOldTime,
+						ULONG32	ulNewTime)
+{
+#if !defined(__TCS__)
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnPreSeek(%ld, %ld)\n", ulOldTime, ulNewTime);
+    }
+#endif
+
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnPostSeek
+ *	Purpose:
+ *	    Called by client engine to inform the client that a seek has
+ *	    just occured. The render is informed the last time for the 
+ *	    stream's time line before the seek, as well as the first new
+ *	    time for the stream's time line after the seek.
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnPostSeek(	ULONG32	ulOldTime,
+						ULONG32	ulNewTime)
+{
+#ifdef __TCS__
+    lastPosition = -1;
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnPostSeek(%ld, %ld)\n", ulOldTime, ulNewTime);
+    }
+#endif
+
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnStop
+ *	Purpose:
+ *	    Called by client engine to inform the client that a stop has
+ *	    just occured. 
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnStop(void)
+{
+    HXTimeval now;
+
+#ifdef __TCS__
+    hookRealAudio_State(eStop);
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnStop()\n");
+    }
+
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("Player %ld stopped.\n", m_lClientIndex);
+        m_bOnStop = TRUE;
+	GetAllStatistics();
+    }
+#endif
+
+    // Find out the current time and subtract the beginning time to
+    // figure out how many seconds we played
+    now = m_pScheduler->GetCurrentSchedulerTime();
+    m_ulStopTime = now.tv_sec;
+
+    GetGlobal()->g_ulNumSecondsPlayed = m_ulStopTime - m_ulStartTime;
+
+    return HXR_OK;
+}
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnPause
+ *	Purpose:
+ *	    Called by client engine to inform the client that a pause has
+ *	    just occured. The render is informed the last time for the 
+ *	    stream's time line before the pause.
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnPause(ULONG32 ulTime)
+{
+#ifdef __TCS__
+    hookRealAudio_State(ePause);
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnPause(%ld)\n", ulTime);
+    }
+#endif 
+
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnBegin
+ *	Purpose:
+ *	    Called by client engine to inform the client that a begin or
+ *	    resume has just occured. The render is informed the first time 
+ *	    for the stream's time line after the resume.
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnBegin(ULONG32 ulTime)
+{
+    HXTimeval now;
+
+#if !defined(__TCS__)
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnBegin(%ld)\n", ulTime);
+    }
+
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("Player %ld beginning playback...\n", m_lClientIndex);
+    }
+#endif
+
+    GetGlobal()->g_bOnBeginOccurred = TRUE;
+
+    // Record the current time, so we can figure out many seconds we played
+    now = m_pScheduler->GetCurrentSchedulerTime();
+    m_ulStartTime = now.tv_sec;
+
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnBuffering
+ *	Purpose:
+ *	    Called by client engine to inform the client that buffering
+ *	    of data is occuring. The render is informed of the reason for
+ *	    the buffering (start-up of stream, seek has occured, network
+ *	    congestion, etc.), as well as percentage complete of the 
+ *	    buffering process.
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnBuffering(ULONG32	ulFlags,
+						UINT16	unPercentComplete)
+{
+#ifdef __TCS__
+static UINT16	lastPct = 0;
+    if (unPercentComplete > 0)
+    {
+	UINT16	nextPct = lastPct + 10;
+	if (unPercentComplete < lastPct)
+	{
+	    lastPct = 0;
+	    nextPct = lastPct + 10;
+	}
+	if (unPercentComplete >= nextPct)
+	{
+	    lastPct = (unPercentComplete / 10) * 10;
+	    nextPct = lastPct + 10;
+	    hookRealAudio_Buffering(eBuffering,lastPct);
+	}
+    }
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnBuffering(%ld, %d)\n", ulFlags, unPercentComplete);
+    }
+#endif
+    if (m_on_buffering_cb)
+        m_on_buffering_cb(ulFlags, unPercentComplete, m_context);
+
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *	Method:
+ *	    IHXClientAdviseSink::OnContacting
+ *	Purpose:
+ *	    Called by client engine to inform the client is contacting
+ *	    hosts(s).
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::OnContacting(const char* pHostName)
+{
+#ifdef __TCS__
+    printf("Contacting\n");
+    hookRealAudio_Buffering(eContacting,0);
+#else
+    if (GetGlobal()->bEnableAdviceSink)
+    {
+        STDOUT("OnContacting(\"%s\")\n", pHostName);
+    }
+#endif
+
+    return HXR_OK;
+}
+
+void ExampleClientAdviceSink::PrintPropName( IHXValues* pHeader )
+{
+    if ( pHeader == NULL )
+    {
+        return ;
+    }
+
+    const char *pChar;
+    ULONG32 pValue;
+    if(HXR_OK == pHeader->GetFirstPropertyULONG32(pChar, pValue))
+    {
+        do
+        {
+            STDOUT("%s %d\n", pChar, pValue);
+        }
+        while(HXR_OK == pHeader->GetNextPropertyULONG32(pChar, pValue));
+    }
+
+    IHXBuffer *pBuffer;
+
+    if(HXR_OK == pHeader->GetFirstPropertyBuffer(pChar, pBuffer))
+    {
+        do
+        {
+            STDOUT("%s %s\n", pChar, (const char *) ( pBuffer->GetBuffer() ));
+		PrintBuffer(pChar, pBuffer->GetBuffer() ,pBuffer->GetSize());
+            HX_RELEASE(pBuffer);
+        } while(HXR_OK == pHeader->GetNextPropertyBuffer(pChar, pBuffer ));
+    }
+    
+	if(HXR_OK == pHeader->GetFirstPropertyCString(pChar, pBuffer))
+    {
+        do
+        {
+            STDERR("%s %s\n", pChar, (const char *) ( pBuffer->GetBuffer() ));
+            HX_RELEASE(pBuffer);
+        } while(HXR_OK == pHeader->GetNextPropertyCString(pChar, pBuffer ));
+    }
+    
+    fflush(stdout);
+}
+
+
+void ExampleClientAdviceSink::SetClipInfo( IHXPlayer* m_pRMAPlayer)
+{
+    bool bSendOnClipInfo = false;
+
+    // Get HXSource and try to get clip infor. 
+    UINT32 sourceCount = m_pRMAPlayer->GetSourceCount();	
+    for (UINT32 sourceID = 0; sourceID < sourceCount; sourceID ++)
+    {
+	// get HXSource
+        STDOUT("========Source %d========\n",sourceID);
+        IUnknown* pUnkSource = NULL;
+        IHXStreamSource* pStreamSrc = NULL;
+
+        if (HXR_OK != m_pRMAPlayer->GetSource (sourceID, pUnkSource))
+        {
+            continue;
+        }
+
+        pUnkSource->QueryInterface(IID_IHXStreamSource, (void **)&pStreamSrc);
+
+        HX_RELEASE(pUnkSource);
+
+        if (!pStreamSrc)
+        {
+            continue;
+        }
+
+	UINT32 num_streams = pStreamSrc->GetStreamCount();
+	
+	STDOUT("====File Header====\n");
+
+        IHXValues* pFileHdr = NULL;
+        pStreamSrc->QueryInterface(IID_IHXValues, (void**)&pFileHdr);
+
+        if ( pFileHdr)
+        {
+	    PrintPropName(pFileHdr);
+        }
+        HX_RELEASE(pFileHdr);
+
+        // get information from Streams
+        for (UINT32 streamID = 0; streamID < num_streams ; streamID++)
+        {
+            STDOUT("====Stream %d====\n",streamID);
+            IUnknown* pUnkStream = NULL;
+
+            if (HXR_OK == pStreamSrc->GetStream(streamID, pUnkStream))
+            {
+                IHXStream* pStream = NULL;
+
+                if (HXR_OK == pUnkStream->QueryInterface(IID_IHXStream,
+                                                         (void**)&pStream))
+                {
+                    IHXValues* pStreamHdr = pStream->GetHeader();
+                    if (pStreamHdr)
+                    {
+                        PrintPropName(pStreamHdr);
+                    }
+                    HX_RELEASE(pStreamHdr);
+                }
+                HX_RELEASE(pStream);
+            }
+            HX_RELEASE(pUnkStream);
+        }
+        STDOUT("---------------------------------------------\n");
+
+        HX_RELEASE(pStreamSrc);
+    }
+}
+
+
+STDMETHODIMP ExampleClientAdviceSink::Func()
+{
+    m_hCallback = 0;
+
+    // set clip info
+	if(m_pPlayer)
+	    SetClipInfo(m_pPlayer);
+
+    return HXR_OK;
+}
+
+void PrintBuffer(const char* pszName,const unsigned char* pbBuf, unsigned int dwBytes)
+{
+	if(pszName == NULL || pbBuf == NULL)
+		return;
+
+	STDOUT("    ");
+	for(unsigned int i= 0; i<dwBytes; i++)	{
+		STDOUT("0x%02x  ",*pbBuf++);
+		if(i % 15 == 0 && i!=0)
+			STDOUT("\n    ");
+	}
+	STDOUT("\n");
+	return;
+}
+
+/*
+ *  IHXGroupSink methods
+ */
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::GroupAdded
+ *  Purpose:
+ *		Notification of a new group being added to the presentation.
+ */
+STDMETHODIMP ExampleClientAdviceSink::GroupAdded( UINT16 /*IN*/ uGroupIndex,
+			    IHXGroup* /*IN*/ pGroup)
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::GroupRemoved
+ *  Purpose:
+ *		Notification of a group being removed from the presentation.
+ */
+STDMETHODIMP ExampleClientAdviceSink::GroupRemoved( UINT16 /*IN*/ uGroupIndex,
+				IHXGroup*  /*IN*/ pGroup)
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::AllGroupsRemoved
+ *  Purpose:
+ *		Notification that all groups have been removed from the 
+ *		current presentation.
+ */
+STDMETHODIMP ExampleClientAdviceSink::AllGroupsRemoved()
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::TrackAdded
+ *  Purpose:
+ *		Notification of a new track being added to a group.
+ */
+STDMETHODIMP ExampleClientAdviceSink::TrackAdded( UINT16 /*IN*/ uGroupIndex,
+			    UINT16     /*IN*/ uTrackIndex,
+			    IHXValues* /*IN*/ pTrack)
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::TrackRemoved
+ *  Purpose:
+ *		Notification of a track being removed from a group.
+ */
+STDMETHODIMP ExampleClientAdviceSink::TrackRemoved( UINT16 /*IN*/ uGroupIndex,
+				UINT16     /*IN*/ uTrackIndex,
+				IHXValues* /*IN*/ pTrack)
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::TrackStarted
+ *  Purpose:
+ *		Notification of a track being started (to get duration, for
+ *		instance...)
+ */
+STDMETHODIMP ExampleClientAdviceSink::TrackStarted( UINT16 /*IN*/ uGroupIndex,
+				UINT16     /*IN*/ uTrackIndex,
+				IHXValues* /*IN*/ pTrack)
+{
+    if ( m_bWaitForTrackStart )
+    {
+        STDOUT("----------------clip info--------------------\n");
+        if(m_pScheduler)
+        {
+            m_hCallback = m_pScheduler->RelativeEnter(this,50);
+        }
+	m_bWaitForTrackStart = FALSE;
+    }
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::TrackStopped
+ *  Purpose:
+ *		Notification of a track being stopped
+ *
+ */
+STDMETHODIMP ExampleClientAdviceSink::TrackStopped( UINT16 /*IN*/ uGroupIndex,
+				UINT16     /*IN*/ uTrackIndex,
+				IHXValues* /*IN*/ pTrack)
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXGroupSink::CurrentGroupSet
+ *  Purpose:
+ *		This group is being currently played in the presentation.
+ */
+STDMETHODIMP ExampleClientAdviceSink::CurrentGroupSet( UINT16 /*IN*/ uGroupIndex,
+				IHXGroup* /*IN*/ pGroup)
+{
+    return HXR_OK;
+}
+
Index: helix-libs/clientapps/clutter/exadvsnk.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exadvsnk.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,324 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXAMPLECLSNK_
+#define _EXAMPLECLSNK_
+
+#include "player.h"
+
+struct IHXClientAdviseSink;
+struct IHXGroupSink;
+struct IUnknown;
+struct IHXRegistry;
+struct IHXScheduler;
+struct IHXCallback;
+struct IHXPlayer;
+struct IHXGroup;
+
+class ExampleClientAdviceSink : public IHXClientAdviseSink,
+                                public IHXGroupSink,
+                                public IHXCallback
+{
+  private:
+    LONG32          m_lRefCount;
+    LONG32          m_lClientIndex;
+    
+    IUnknown*       m_pUnknown;
+    IHXRegistry*    m_pRegistry;
+    IHXScheduler*   m_pScheduler;
+    
+    UINT32          m_ulStartTime;
+    UINT32          m_ulStopTime;
+    
+    UINT32    m_lCurrentBandwidth;
+    UINT32    m_lAverageBandwidth;
+    HXBOOL      m_bOnStop;
+  
+    HXBOOL      m_bWaitForTrackStart;
+   
+    on_buffering_cb_t m_on_buffering_cb;
+    on_pos_length_cb_t m_on_pos_length_cb; 
+    void *m_context;    /* a argument passed by texture-helix lib */
+
+    // IHXCallback
+	IHXPlayer*		m_pPlayer;
+    ULONG32         m_hCallback;
+    ~ExampleClientAdviceSink();
+    HX_RESULT DumpRegTree(const char* pszTreeName );
+
+
+        void GetStatistics (char* /*IN*/ pszRegistryKey);
+    void GetAllStatistics (void);
+	void SetClipInfo( IHXPlayer* m_pRMAPlayer);
+	void PrintPropName( IHXValues* pHeader );
+
+  public:
+
+    ExampleClientAdviceSink(IUnknown* /*IN*/ pUnknown, LONG32 /*IN*/ lClientIndex, on_buffering_cb_t on_buffer_cb, on_pos_length_cb_t on_pos_length_cb, void *context);
+
+    /*
+     *  IUnknown methods
+     */
+    STDMETHOD(QueryInterface) (THIS_
+                               REFIID riid,
+                               void** ppvObj);
+    
+    STDMETHOD_(ULONG32,AddRef) (THIS);
+
+    STDMETHOD_(ULONG32,Release) (THIS);
+
+    /*
+     *  IHXClientAdviseSink methods
+     */
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnPosLength
+     *  Purpose:
+     *      Called to advise the client that the position or length of the
+     *      current playback context has changed.
+     */
+    STDMETHOD(OnPosLength) (THIS_
+                            UINT32    ulPosition,
+                            UINT32    ulLength);
+    
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnPresentationOpened
+     *  Purpose:
+     *      Called to advise the client a presentation has been opened.
+     */
+    STDMETHOD(OnPresentationOpened) (THIS);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnPresentationClosed
+     *  Purpose:
+     *      Called to advise the client a presentation has been closed.
+     */
+    STDMETHOD(OnPresentationClosed) (THIS);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnStatisticsChanged
+     *  Purpose:
+     *      Called to advise the client that the presentation statistics
+     *      have changed. 
+     */
+    STDMETHOD(OnStatisticsChanged) (THIS);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnPreSeek
+     *  Purpose:
+     *      Called by client engine to inform the client that a seek is
+     *      about to occur. The render is informed the last time for the 
+     *      stream's time line before the seek, as well as the first new
+     *      time for the stream's time line after the seek will be completed.
+     *
+     */
+    STDMETHOD (OnPreSeek) (THIS_
+                           ULONG32 ulOldTime,
+                           ULONG32  ulNewTime);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnPostSeek
+     *  Purpose:
+     *      Called by client engine to inform the client that a seek has
+     *      just occured. The render is informed the last time for the 
+     *      stream's time line before the seek, as well as the first new
+     *      time for the stream's time line after the seek.
+     *
+     */
+    STDMETHOD (OnPostSeek) (THIS_
+                            ULONG32 ulOldTime,
+                            ULONG32 ulNewTime);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnStop
+     *  Purpose:
+     *      Called by client engine to inform the client that a stop has
+     *      just occured. 
+     *
+     */
+    STDMETHOD (OnStop) (THIS);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnPause
+     *  Purpose:
+     *      Called by client engine to inform the client that a pause has
+     *      just occured. The render is informed the last time for the 
+     *      stream's time line before the pause.
+     *
+     */
+    STDMETHOD (OnPause) (THIS_
+                         ULONG32 ulTime);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnBegin
+     *  Purpose:
+     *      Called by client engine to inform the client that a begin or
+     *      resume has just occured. The render is informed the first time 
+     *      for the stream's time line after the resume.
+     *
+     */
+    STDMETHOD (OnBegin) (THIS_
+                         ULONG32 ulTime);
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnBuffering
+     *  Purpose:
+     *      Called by client engine to inform the client that buffering
+     *      of data is occuring. The render is informed of the reason for
+     *      the buffering (start-up of stream, seek has occured, network
+     *      congestion, etc.), as well as percentage complete of the 
+     *      buffering process.
+     *
+     */
+    STDMETHOD (OnBuffering) (THIS_
+                             ULONG32 ulFlags,
+                             UINT16 unPercentComplete);
+
+
+    /************************************************************************
+     *  Method:
+     *      IHXClientAdviseSink::OnContacting
+     *  Purpose:
+     *      Called by client engine to inform the client is contacting
+     *      hosts(s).
+     *
+     */
+    STDMETHOD (OnContacting) (THIS_
+                              const char* pHostName);
+
+    // IHXCallback
+    STDMETHOD(Func)            (THIS);
+
+    /*
+     *  IHXGroupSink methods
+     */
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::GroupAdded
+    *  Purpose:
+    *		Notification of a new group being added to the presentation.
+    */
+    STDMETHOD(GroupAdded)    (THIS_
+			    UINT16 	    /*IN*/ uGroupIndex,
+			    IHXGroup*	    /*IN*/ pGroup);
+
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::GroupRemoved
+    *  Purpose:
+    *		Notification of a group being removed from the presentation.
+    */
+    STDMETHOD(GroupRemoved)    (THIS_
+				UINT16 	    /*IN*/ uGroupIndex,
+				IHXGroup*  /*IN*/ pGroup);
+
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::AllGroupsRemoved
+    *  Purpose:
+    *		Notification that all groups have been removed from the 
+    *		current presentation.
+    */
+    STDMETHOD(AllGroupsRemoved)  (THIS);
+
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::TrackAdded
+    *  Purpose:
+    *		Notification of a new track being added to a group.
+    */
+    STDMETHOD(TrackAdded)  (THIS_
+			    UINT16 	    /*IN*/ uGroupIndex,
+			    UINT16 	    /*IN*/ uTrackIndex,
+			    IHXValues*	    /*IN*/ pTrack);
+
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::TrackRemoved
+    *  Purpose:
+    *		Notification of a track being removed from a group.
+    */
+    STDMETHOD(TrackRemoved)    (THIS_
+				UINT16 		/*IN*/ uGroupIndex,
+				UINT16 		/*IN*/ uTrackIndex,
+				IHXValues*	/*IN*/ pTrack);
+
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::TrackStarted
+    *  Purpose:
+    *		Notification of a track being started (to get duration, for
+    *		instance...)
+    */
+    STDMETHOD (TrackStarted)	(THIS_
+				UINT16	    /*IN*/ uGroupIndex,
+				UINT16	    /*IN*/ uTrackIndex,
+				IHXValues* /*IN*/ pTrack) ;
+    
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::TrackStopped
+    *  Purpose:
+    *		Notification of a track being stopped
+    *
+    */
+    STDMETHOD(TrackStopped)	(THIS_
+				UINT16	    /*IN*/ uGroupIndex,
+				UINT16	    /*IN*/ uTrackIndex,
+				IHXValues* /*IN*/ pTrack);
+
+    /************************************************************************
+    *  Method:
+    *      IHXGroupSink::CurrentGroupSet
+    *  Purpose:
+    *		This group is being currently played in the presentation.
+    */
+    STDMETHOD(CurrentGroupSet)	(THIS_
+				UINT16 	    /*IN*/ uGroupIndex,
+				IHXGroup*  /*IN*/ pGroup);
+
+};
+
+#endif /* _EXAMPLECLSNK_ */
Index: helix-libs/clientapps/clutter/exaumgr.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exaumgr.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,137 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include <stdio.h>
+#include "hxtypes.h"
+#include "hxcom.h"
+#include "hxauth.h"
+#include "hxstrutl.h"
+#include "exaumgr.h"
+#include <ctype.h>
+#include "print.h"
+
+
+#include "globals.h"
+struct _stGlobals*& GetGlobal(); //in main.cpp
+
+
+
+ExampleAuthenticationManager::ExampleAuthenticationManager() :
+    m_lRefCount(0),
+    m_bSentPassword(FALSE)
+{
+}
+
+ExampleAuthenticationManager::~ExampleAuthenticationManager()
+{
+}
+
+STDMETHODIMP
+ExampleAuthenticationManager::QueryInterface(REFIID riid, void**ppvObj)
+{
+    if(IsEqualIID(riid, IID_IUnknown))
+    {
+        AddRef();
+        *ppvObj = (IUnknown*)(IHXAuthenticationManager*)this;
+        return HXR_OK;
+    }
+    else if(IsEqualIID(riid, IID_IHXAuthenticationManager))
+    {
+        AddRef();
+        *ppvObj = (IHXAuthenticationManager*)this;
+        return HXR_OK;
+    }
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+STDMETHODIMP_(UINT32)
+ExampleAuthenticationManager::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+STDMETHODIMP_(UINT32)
+ExampleAuthenticationManager::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+STDMETHODIMP
+ExampleAuthenticationManager::HandleAuthenticationRequest(IHXAuthenticationManagerResponse* pResponse)
+{
+    char      username[1024] = ""; /* Flawfinder: ignore */
+    char      password[1024] = ""; /* Flawfinder: ignore */
+    HX_RESULT res = HXR_FAIL;
+    
+    if( !m_bSentPassword )
+    {
+        res = HXR_OK;
+        if (GetGlobal()->bEnableVerboseMode)
+            STDOUT("\nSending Username and Password...\n");
+
+        SafeStrCpy(username,  GetGlobal()->g_pszUsername, 1024);
+        SafeStrCpy(password,  GetGlobal()->g_pszPassword, 1024);
+
+        //strip trailing whitespace
+        char* c;
+        for(c = username + strlen(username) - 1; 
+            c > username && isspace(*c);
+            c--)
+            ;
+        *(c+1) = 0;
+    
+        for(c = password + strlen(password) - 1; 
+            c > password && isspace(*c);
+            c--)
+            ;
+        *(c+1) = 0;
+        
+        m_bSentPassword = TRUE;
+    }
+
+    if (GetGlobal()->bEnableVerboseMode && FAILED(res) )
+        STDOUT("\nInvalid Username and/or Password.\n");
+    
+    pResponse->AuthenticationRequestDone(res, username, password);
+    return res;
+}
+
Index: helix-libs/clientapps/clutter/exaumgr.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exaumgr.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,56 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXAUMGR_H_
+#define _EXAUMGR_H_
+
+#include "hxauth.h"
+
+class ExampleAuthenticationManager : public IHXAuthenticationManager
+{
+private:
+    INT32 m_lRefCount;
+    HXBOOL  m_bSentPassword;
+    ~ExampleAuthenticationManager();
+
+public:
+    ExampleAuthenticationManager();
+    STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj);
+    STDMETHOD_(UINT32,AddRef) (THIS);
+    STDMETHOD_(UINT32,Release) (THIS);
+
+    STDMETHOD(HandleAuthenticationRequest) (IHXAuthenticationManagerResponse* pResponse);
+};
+#endif
Index: helix-libs/clientapps/clutter/excallback.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/excallback.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,38 @@
+#include "excallback.h"
+
+STDMETHODIMP ExCallback::QueryInterface(REFIID riid, void** ppvObj)
+{
+	if (IsEqualIID(riid, IID_IHXCallback))
+	{
+		AddRef();
+		*ppvObj = (IHXCallback*)this;
+		return HXR_OK;
+	}
+	else if (IsEqualIID(riid, IID_IUnknown))
+	{
+		AddRef();
+		*ppvObj = this;
+		return HXR_OK;
+	}
+
+	*ppvObj = NULL;
+	return HXR_NOINTERFACE;
+}
+
+STDMETHODIMP_(ULONG32) ExCallback::AddRef()
+{
+	return HXR_OK;
+}
+
+STDMETHODIMP_(ULONG32) ExCallback::Release()
+{
+	return HXR_OK;
+}
+
+STDMETHODIMP ExCallback::Func(void)
+{
+	UINT32 sleepTime = 0;
+	m_pKicker->Kick(HXGetCurrentThreadID, &sleepTime);
+	printf("Get called, sleeptime:%d\n", sleepTime);
+	m_pScheduler->RelativeEnter(this, sleepTime/1000);
+}
Index: helix-libs/clientapps/clutter/excallback.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/excallback.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,32 @@
+#ifndef _EX_CALLBACK_H_
+#define _EX_CALLBACK_H_
+
+#include "hxcom.h"
+#include "hxengin.h"
+#include "ihxmedpltfm.h"
+#include "thrdutil.h"
+
+class ExCallback : public IHXCallback
+{
+	public:
+		ExCallback(IHXScheduler *pIHXScheduler, IHXMediaPlatformKicker *pKicker) : m_pScheduler(pIHXScheduler), m_pKicker(pKicker){};
+
+		/*
+		 *      *  IUnknown methods
+		 *           */
+		STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj);
+		STDMETHOD_(ULONG32,AddRef) (THIS);
+		STDMETHOD_(ULONG32,Release) (THIS);
+
+		/*
+		 *      *  IHXCallback methods
+		 *           */
+		STDMETHOD(Func) (THIS);
+	private:
+		IHXScheduler *m_pScheduler;
+		IHXMediaPlatformKicker* m_pKicker;
+
+};
+
+
+#endif 
Index: helix-libs/clientapps/clutter/excontxt.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/excontxt.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,315 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include "hxtypes.h"
+
+#include "hxwintyp.h"
+#include "hxcom.h"
+#include "hxcomm.h"
+#include "hxwin.h"
+#include "fivemmap.h"
+
+#include "hxbuffer.h"
+#include "hxmangle.h"
+
+#include "hxclsnk.h"
+#include "hxgroup.h"
+#include "hxerror.h"
+#include "hxprefs.h"
+#include "hxstrutl.h"
+
+#include "exadvsnk.h"
+#include "exstateadvsnk.h"
+#include "exerror.h"
+#include "exsitsup.h"
+#include "exaumgr.h"
+#include "hxprdnld.h"
+#include "exprdnld.h"
+
+#include "excontxt.h"
+
+extern HXBOOL bEnableAdviceSink;
+
+
+ExampleClientContext::ExampleClientContext(LONG32 lClientIndex)
+    : m_lRefCount(0)
+    , m_lClientIndex(lClientIndex)
+    , m_pClientSink(NULL)
+    , m_pClientStateSink(NULL)
+    , m_pErrorSink(NULL)
+    , m_pAuthMgr(NULL)
+    , m_pSiteSupplier(NULL)
+    , m_pDefaultPrefs(NULL)
+#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS)
+    , m_pPrgDnldStatusObserver(NULL)
+#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS.
+{
+}
+
+
+ExampleClientContext::~ExampleClientContext()
+{
+    Close();
+};
+
+void ExampleClientContext::Init(IUnknown*	 /*IN*/ pUnknown,
+				IHXPreferences* /*IN*/ pPreferences,
+				char*		 /*IN*/ pszGUID,
+                on_buffering_cb_t   on_buffering_cb,
+                on_pos_length_cb_t on_pos_length_cb,
+                on_state_change_cb_t on_state_change_cb,
+                on_new_frame_cb_t   on_new_frame_cb,
+                void *context)
+{
+    char* pszCipher = NULL;
+
+	
+    m_pClientSink	= new ExampleClientAdviceSink(pUnknown, m_lClientIndex, on_buffering_cb, on_pos_length_cb, context);
+
+    m_pClientStateSink	= new ExampleClientStateAdviceSink(pUnknown, m_lClientIndex, on_state_change_cb, context);
+    m_pErrorSink	= new ExampleErrorSink(pUnknown);
+#if defined(HELIX_FEATURE_AUTHENTICATION)
+    m_pAuthMgr          = new ExampleAuthenticationManager();
+    if(m_pAuthMgr)
+    {
+	m_pAuthMgr->AddRef();
+    }
+
+#endif /* #if defined(HELIX_FEATURE_AUTHENTICATION) */
+#if defined(HELIX_FEATURE_VIDEO)
+    m_pSiteSupplier	= new ExampleSiteSupplier(pUnknown, on_new_frame_cb, context);
+#endif 
+
+#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS)
+    m_pPrgDnldStatusObserver = new ExamplePDStatusObserver(pUnknown);
+#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS.
+
+    if (m_pClientSink)
+    {
+	m_pClientSink->AddRef();
+    }
+    
+    if (m_pErrorSink)
+    {
+	m_pErrorSink->AddRef();
+    }
+
+    if (m_pClientStateSink)
+        m_pClientStateSink->AddRef();
+
+    if(m_pSiteSupplier)
+    {
+	m_pSiteSupplier->AddRef();
+    }
+
+    if (pPreferences)
+    {
+	m_pDefaultPrefs = pPreferences;
+	m_pDefaultPrefs->AddRef();
+    }
+
+    if (pszGUID && *pszGUID)
+    {
+	// Encode GUID
+	pszCipher = Cipher(pszGUID);
+	SafeStrCpy(m_pszGUID,  pszCipher, 256);
+    }
+    else
+    {
+	m_pszGUID[0] = '\0';
+    }
+}
+
+void ExampleClientContext::Close()
+{
+    HX_RELEASE(m_pClientSink);
+    HX_RELEASE(m_pClientStateSink);
+    HX_RELEASE(m_pErrorSink);
+#if defined(HELIX_FEATURE_AUTHENTICATION)
+    HX_RELEASE(m_pAuthMgr);
+#endif /* #if defined(HELIX_FEATURE_AUTHENTICATION) */
+    HX_RELEASE(m_pSiteSupplier);
+    HX_RELEASE(m_pDefaultPrefs);
+#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS)
+    HX_RELEASE(m_pPrgDnldStatusObserver);
+#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS.
+}
+
+
+
+// *** IUnknown methods ***
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::QueryInterface
+//  Purpose:
+//	Implement this to export the interfaces supported by your 
+//	object.
+//
+STDMETHODIMP ExampleClientContext::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IUnknown))
+    {
+	AddRef();
+	*ppvObj = this;
+	return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXPreferences))
+    {
+	AddRef();
+	*ppvObj = (IHXPreferences*)this;
+	return HXR_OK;
+    }
+    else if (m_pClientSink && 
+	     m_pClientSink->QueryInterface(riid, ppvObj) == HXR_OK)
+    {
+	return HXR_OK;
+    }
+    else if (m_pErrorSink && 
+	     m_pErrorSink->QueryInterface(riid, ppvObj) == HXR_OK)
+    {
+	return HXR_OK;
+    }
+    else if (m_pClientStateSink &&
+            m_pClientStateSink->QueryInterface(riid, ppvObj) == HXR_OK)
+    {
+        return HXR_OK;
+    }
+#if defined(HELIX_FEATURE_AUTHENTICATION)
+    else if(m_pAuthMgr &&
+	    m_pAuthMgr->QueryInterface(riid, ppvObj) == HXR_OK)
+    {
+	return HXR_OK;
+    }
+#endif /* #if defined(HELIX_FEATURE_AUTHENTICATION) */
+    else if(m_pSiteSupplier &&
+	    m_pSiteSupplier->QueryInterface(riid, ppvObj) == HXR_OK)
+    {
+	return HXR_OK;
+    }
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::AddRef
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleClientContext::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::Release
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleClientContext::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+
+// *** IUnknown methods ***
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IHXPreferences::ReadPref
+//  Purpose:
+//	Read a Preference from the registry.
+//
+STDMETHODIMP
+ExampleClientContext::ReadPref(const char* pref_key, IHXBuffer*& buffer)
+{
+    HX_RESULT hResult	= HXR_OK;
+    char*     pszCipher = NULL;
+    
+    if ((stricmp(pref_key, CLIENT_GUID_REGNAME) == 0) &&
+	(*m_pszGUID))
+    {
+	// Create a Buffer 
+	buffer = new CHXBuffer();
+	buffer->AddRef();
+
+	// Copy the encoded GUID into the buffer
+	buffer->Set((UCHAR*)m_pszGUID, strlen(m_pszGUID) + 1);
+    }
+    else if (m_pDefaultPrefs)
+    {
+	hResult = m_pDefaultPrefs->ReadPref(pref_key, buffer);
+    }
+    else
+    {
+	hResult = HXR_NOTIMPL;
+    }
+
+    return hResult;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IHXPreferences::WritePref
+//  Purpose:
+//	Write a Preference to the registry.
+//
+STDMETHODIMP
+ExampleClientContext::WritePref(const char* pref_key, IHXBuffer* buffer)
+{
+    if (m_pDefaultPrefs)
+    {
+	return m_pDefaultPrefs->WritePref(pref_key, buffer);
+    }
+    else	
+    {
+	return HXR_OK;
+    }
+}
+
+EHXClientState ExampleClientContext::GetState()
+{
+    return m_pClientStateSink->GetState();
+};
Index: helix-libs/clientapps/clutter/excontxt.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/excontxt.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,106 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+#ifndef _EXCONTXT_H_
+#define _EXCONTXT_H_
+
+#include "exerror.h"
+#include "exsitsup.h"
+#include "hxprefs.h"
+#include "player.h"
+#include "hxclsnk.h"
+
+struct IUnknown;
+struct IHXPreferences;
+class ExampleClientAdviceSink;
+class ExampleClientStateAdviceSink;
+class ExampleErrorMessages;
+class ExampleAuthenticationManager;
+class ExamplePDStatusObserver;
+
+
+class ExampleClientContext : public IHXPreferences
+{
+private:
+    LONG32			    m_lRefCount;
+    LONG32                          m_lClientIndex;
+
+    ExampleClientAdviceSink*	    m_pClientSink;
+    ExampleClientStateAdviceSink*    m_pClientStateSink;
+    ExampleErrorSink*		    m_pErrorSink;
+    ExampleAuthenticationManager*   m_pAuthMgr;
+
+    ExampleSiteSupplier*	    m_pSiteSupplier;
+    ExamplePDStatusObserver*        m_pPrgDnldStatusObserver;
+    IHXPreferences*		    m_pDefaultPrefs;
+    char			    m_pszGUID[256]; /* Flawfinder: ignore */
+
+
+public:
+
+    ExampleClientContext(LONG32 /*IN*/ lClientIndex);
+    ~ExampleClientContext();
+
+    void Init(IUnknown*	       /*IN*/ pUnknown,
+	      IHXPreferences* /*IN*/ pPreferences,
+	      char*	       /*IN*/ pszGUID,
+          on_buffering_cb_t on_buffering_cb = NULL,
+          on_pos_length_cb_t on_pos_length_cb = NULL,
+          on_state_change_cb_t on_state_change_cb = NULL,
+          on_new_frame_cb_t on_new_frame_cb = NULL,
+          void *context = NULL);
+    void Close();
+
+    EHXClientState GetState(); 
+
+    /*
+     * IUnknown methods
+     */
+    STDMETHOD(QueryInterface)	(THIS_
+				REFIID riid,
+				void** ppvObj);
+
+    STDMETHOD_(ULONG32,AddRef)	(THIS);
+    STDMETHOD_(ULONG32,Release)	(THIS);
+
+    /*
+     * IHXPreferences methods
+     */
+    STDMETHOD(ReadPref)		(THIS_ const char* pref_key, 
+				 IHXBuffer*& buffer);
+    STDMETHOD(WritePref)	(THIS_ const char* pref_key,
+				 IHXBuffer* buffer);
+};
+
+#endif
Index: helix-libs/clientapps/clutter/exerror.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exerror.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,230 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include "hxtypes.h"
+
+#include "hxcom.h"
+#include "hxcomm.h"
+#include "hxerror.h"
+#include "hxstrutl.h"
+#include "hxcore.h"
+#include "hxassert.h"
+#include "hxbuffer.h"
+
+#ifdef __TCS__
+#include "hxresult.h"
+#endif
+
+#if !defined(HELIX_CONFIG_MINIMIZE_SIZE)
+#include "HXErrorCodeStrings.h"
+#endif
+
+#include "exerror.h"
+
+#include <stdio.h>
+#include "print.h"
+
+#include "globals.h"
+struct _stGlobals*& GetGlobal(); //in main.cpp
+
+#ifdef __TCS__
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+void hookRealAudio_ReportError(int err, long errVal);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+ExampleErrorSink::ExampleErrorSink(IUnknown* pUnknown) 
+    : m_lRefCount(0),
+      m_pPlayer(NULL)
+{
+    IHXClientEngine* pEngine = NULL;
+    pUnknown->QueryInterface(IID_IHXClientEngine, (void**)&pEngine );
+    if( pEngine )
+    {
+        IUnknown* pTmp = NULL;
+        pEngine->GetPlayer(0, pTmp);
+        m_pPlayer = (IHXPlayer*)pTmp;
+    }
+    
+    HX_RELEASE( pEngine );
+    HX_ASSERT(m_pPlayer);
+}
+
+ExampleErrorSink::~ExampleErrorSink()
+{
+    HX_RELEASE(m_pPlayer);
+}
+
+// *** IUnknown methods ***
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//  IUnknown::QueryInterface
+//  Purpose:
+//  Implement this to export the interfaces supported by your 
+//  object.
+//
+STDMETHODIMP ExampleErrorSink::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IUnknown))
+    {
+        AddRef();
+        *ppvObj = (IUnknown*)(IHXErrorSink*)this;
+        return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXErrorSink))
+    {
+        AddRef();
+        *ppvObj = (IHXErrorSink*) this;
+        return HXR_OK;
+    }
+
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//  IUnknown::AddRef
+//  Purpose:
+//  Everyone usually implements this the same... feel free to use
+//  this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleErrorSink::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//  IUnknown::Release
+//  Purpose:
+//  Everyone usually implements this the same... feel free to use
+//  this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleErrorSink::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+/*
+ *  IHXErrorSink methods
+ */
+
+STDMETHODIMP 
+ExampleErrorSink::ErrorOccurred(const UINT8 unSeverity,  
+                                const ULONG32   ulHXCode,
+                                const ULONG32   ulUserCode,
+                                const char* pUserString,
+                                const char* pMoreInfoURL
+                                )
+{
+    char HXDefine[256]; /* Flawfinder: ignore */
+
+    // Store the code, so we can return it from main()
+    GetGlobal()->g_Error = ulHXCode;
+
+    ConvertErrorToString(ulHXCode, HXDefine, 256);
+
+#ifdef __TCS__
+    hookRealAudio_ReportError(ulHXCode,ulUserCode);
+#else
+    STDOUT("Report(%d, %ld, \"%s\", %ld, \"%s\", \"%s\")\n",
+           unSeverity,
+           ulHXCode,
+           (pUserString && *pUserString) ? pUserString : "(NULL)",
+           ulUserCode,
+           (pMoreInfoURL && *pMoreInfoURL) ? pMoreInfoURL : "(NULL)",
+           HXDefine);
+#endif
+
+    return HXR_OK;
+}
+
+void
+ExampleErrorSink::ConvertErrorToString(const ULONG32 ulHXCode, char* pszBuffer, UINT32 ulBufLen)
+{
+    IHXErrorMessages* pErrMsg = NULL;
+
+    if( !pszBuffer)
+        return;
+    
+    pszBuffer[0]='\0';
+
+    HX_ASSERT(m_pPlayer);
+    if( m_pPlayer)
+    {
+        m_pPlayer->QueryInterface(IID_IHXErrorMessages, (void**)&pErrMsg);
+        if( pErrMsg )
+        {
+            IHXBuffer* pMessage = pErrMsg->GetErrorText(ulHXCode);
+            if( pMessage )
+            {
+                SafeStrCpy( pszBuffer, (const char*)pMessage->GetBuffer(), ulBufLen);
+                pMessage->Release();
+            }
+        }
+        HX_RELEASE(pErrMsg);
+    }
+ 
+    if( strlen(pszBuffer)==0 )
+    {
+#if !defined(HELIX_CONFIG_MINIMIZE_SIZE)        
+	const char* pszHXCodeString = HXErrorCodeToString(ulHXCode);
+        if (pszHXCodeString)
+        {   
+            SafeSprintf( pszBuffer, ulBufLen, "%s", pszHXCodeString);
+        }
+        else
+#endif        
+        {
+            HX_ASSERT(FALSE);
+            SafeSprintf( pszBuffer, ulBufLen, "Can't convert error code %p - make sure it's defined in common/util/HXErrorCodeStrings.c", ulHXCode );
+        }
+    }
+}
+
Index: helix-libs/clientapps/clutter/exerror.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exerror.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,92 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXAMPLEERRORMESSAGES_
+#define _EXAMPLEERRORMESSAGES_
+
+#include "hxerror.h"
+
+struct IUnknown;
+struct IHXErrorMessages;
+struct IHXPlayer;
+
+class ExampleErrorSink : public IHXErrorSink
+{
+public:
+
+    ExampleErrorSink(IUnknown* pUnknown);
+    ~ExampleErrorSink();
+
+    /*
+     *  IUnknown methods
+     */
+    STDMETHOD(QueryInterface)	(THIS_
+				REFIID riid,
+				void** ppvObj);
+
+    STDMETHOD_(ULONG32,AddRef)	(THIS);
+
+    STDMETHOD_(ULONG32,Release)	(THIS);
+
+    /*
+     *  IHXErrorSink methods
+     */
+
+    /************************************************************************
+     *	Method:
+     *	    IHXErrorSink::ErrorOccurred
+     *	Purpose:
+     *	    After you have registered your error sink with an IHXErrorSinkControl 
+     *	    (either in the server or player core) this method will be called to 
+     *	    report an error, event, or status message.
+     *
+     *	    The meaning of the arguments is exactly as described in
+     *	    hxerror.h
+     */
+    STDMETHOD(ErrorOccurred)	(THIS_
+				const UINT8	unSeverity,  
+				const ULONG32	ulHXCode,
+				const ULONG32	ulUserCode,
+				const char*	pUserString,
+				const char*	pMoreInfoURL
+				);
+
+protected:
+    LONG32 m_lRefCount;
+    IHXPlayer* m_pPlayer;
+
+    void   ConvertErrorToString (const ULONG32 ulHXCode, char* pszBuffer, UINT32 ulBufLen);
+};
+#endif /*_EXAMPLEERRORMESSAGES_*/
Index: helix-libs/clientapps/clutter/exprdnld.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exprdnld.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,468 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include "hxcom.h"
+#include "hxtypes.h"
+#include "hxcore.h"
+#include "hxprdnld.h"
+#include "exprdnld.h"
+#include "print.h"
+
+#include "globals.h"
+struct _stGlobals*& GetGlobal();
+
+UINT32 GetTime(); // /In main.cpp.
+
+// /#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS)
+/************************************************************************
+ *  Method:
+ *    Constructor
+ */
+ExamplePDStatusObserver::ExamplePDStatusObserver(IUnknown* pUnkPlayer)
+    : m_lRefCount(0)
+    , m_pPrgDnldStatusMgr(NULL)
+    , m_pUnkPlayer(pUnkPlayer)
+    , m_pHXPlayer(NULL)
+    , m_bPlayerIsPausedByThis(FALSE)
+    , m_bFirstPDStatusMessage(TRUE)
+    , m_ulTotalDurReported(HX_PROGDOWNLD_UNKNOWN_DURATION)
+    , m_ulDurSoFar(HX_PROGDOWNLD_UNKNOWN_DURATION)
+    , m_ulCurStatusUpdateGranularity(
+            HX_PROGDOWNLD_DEFAULT_STATUSREPORT_INTERVAL_MSEC)
+    , m_bInitialPrerollUpateGranularitySet(FALSE)
+    , m_bDownloadIsComplete(FALSE)
+{
+    if (m_pUnkPlayer)
+    {
+	m_pUnkPlayer->QueryInterface(IID_IHXPlayer,
+			(void**)&m_pHXPlayer);
+
+	m_pUnkPlayer->QueryInterface(IID_IHXPDStatusMgr,
+			(void**)&m_pPrgDnldStatusMgr);
+
+        if (m_pPrgDnldStatusMgr)
+        {
+            // /Add ourselves as an observer of progressive download playback:
+            m_pPrgDnldStatusMgr->AddObserver(this);
+            // /Set granularity of status reports to 10 per second until we
+            // know enough about the situation to go back to getting reports
+            // at the default interval (every 5 seconds).  Do that as soon
+            // as we receive the first progress report:
+            m_ulCurStatusUpdateGranularity = 100;
+        }
+
+	m_pUnkPlayer->AddRef();
+    }
+};
+
+/************************************************************************
+ *  Method:
+ *    Destructor
+ */
+ExamplePDStatusObserver::~ExamplePDStatusObserver()
+{
+    if (m_pPrgDnldStatusMgr)
+    {
+        m_pPrgDnldStatusMgr->RemoveObserver(this);
+    }
+    HX_RELEASE(m_pPrgDnldStatusMgr);
+    HX_RELEASE(m_pHXPlayer);
+    HX_RELEASE(m_pUnkPlayer);
+}
+
+/************************************************************************
+ *  Method:
+ *    IUnknown::QueryInterface
+ */
+STDMETHODIMP 
+ExamplePDStatusObserver::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IUnknown))
+    {
+	AddRef();
+	*ppvObj = (IUnknown*)(IHXPDStatusObserver*)this;
+	return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXPDStatusObserver))
+    {
+	AddRef();
+	*ppvObj = (IHXPDStatusObserver*)this;
+	return HXR_OK;
+    }
+
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+/************************************************************************
+ *  Method:
+ *    IUnknown::AddRef
+ */
+STDMETHODIMP_(ULONG32) 
+ExamplePDStatusObserver::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+/************************************************************************
+ *  Method:
+ *    IUnknown::Release
+ */
+STDMETHODIMP_(ULONG32) 
+ExamplePDStatusObserver::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+
+/*
+ *  IHXPDStatusObserver methods
+ */
+
+/************************************************************************
+ *  Method:
+ *      IHXPDStatusObserver::OnDownloadProgress
+ *
+ *  Purpose:
+ *      Notification from IHXPDStatusMgr of download progress when
+ *      file size changes.
+ *
+ *      lTimeSurplus:
+ *      - When negative, the absolute value of it is the estimated number
+ *      of milliseconds of wall-clock time that need to pass while
+ *      downloading continues before reaching the point at which playback
+ *      can resume and play the remainder of the stream without having to
+ *      buffer, assuming that playback is paused and remains so during
+ *      that period.
+ *      - When positive, it is the estimated number of milliseconds of
+ *      wall-clock time between when the download should complete and when
+ *      the natural content play-out duration will be reached, assuming
+ *      playback is currently progressing and that no pause will occur.
+ *
+ *      Note: ulNewDurSoFar can be HX_PROGDOWNLD_UNKNOWN_DURATION if the
+ *      IHXMediaBytesToMediaDur was not available to, or was unable to
+ *      convert the bytes to a duration for the IHXPDStatusMgr calling this:
+ */
+STDMETHODIMP
+ExamplePDStatusObserver::OnDownloadProgress(
+              IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource,
+              UINT32 /*IN*/ ulNewDurSoFar,
+              UINT32 /*IN*/ ulNewBytesSoFar,
+              INT32  /*IN*/ lTimeSurplus)
+{
+    m_ulDurSoFar = ulNewDurSoFar;
+
+    if (m_ulCurStatusUpdateGranularity <
+            HX_PROGDOWNLD_DEFAULT_STATUSREPORT_INTERVAL_MSEC)
+    {
+        if (m_bInitialPrerollUpateGranularitySet)
+        {
+            if (HX_PROGDOWNLD_UNKNOWN_DURATION != ulNewDurSoFar  &&
+                    // /Preroll is done, so reset update interval back to default:
+                    GetGlobal()->g_bOnBeginOccurred)
+            {
+                m_ulCurStatusUpdateGranularity =
+                        HX_PROGDOWNLD_DEFAULT_STATUSREPORT_INTERVAL_MSEC;
+                m_pPrgDnldStatusMgr->SetStatusUpdateGranularityMsec(
+                        m_ulCurStatusUpdateGranularity);
+            }
+        }
+        else if (!GetGlobal()->g_bOnBeginOccurred)
+        {
+            if (HXR_OK == m_pPrgDnldStatusMgr->SetStatusUpdateGranularityMsec(
+                    m_ulCurStatusUpdateGranularity))
+            {
+                m_bInitialPrerollUpateGranularitySet = TRUE;
+            }
+        }
+    }
+
+    UINT32 ulCurPlayTime = 0;
+
+    HXBOOL bPauseWasAttempted = FALSE;
+    HXBOOL bPauseOccurred     = FALSE;
+    HXBOOL bResumeWasAttempted = FALSE;
+    HXBOOL bResumeOccurred = FALSE;
+
+    
+    if (m_pHXPlayer)
+    {
+        ulCurPlayTime = m_pHXPlayer->GetCurrentPlayTime();
+
+        if (GetGlobal()->g_bEnableSlowStart  &&
+                lTimeSurplus != HX_PROGDOWNLD_UNKNOWN_TIME_SURPLUS)
+        {
+            // /"slow start" is enabled so if we have run dry of data,
+            // pause and wait for more data:
+            if (!m_bPlayerIsPausedByThis)
+            {
+                if (!m_bDownloadIsComplete  &&  lTimeSurplus<0)
+                {
+                    // /Use a 1000-millisecond allowance for variation:
+                    if (lTimeSurplus < -1000)
+                    {
+                        bPauseWasAttempted = TRUE;
+                        bPauseOccurred = m_bPlayerIsPausedByThis =
+                                (HXR_OK == m_pHXPlayer->Pause());
+                    }
+                }
+            }
+            else // /paused; see if we can resume yet:
+            {
+                if (lTimeSurplus > 0)
+                {
+                    // /Use a 1000-millisecond allowance for variation:
+                    if (lTimeSurplus > 1000)
+                    {
+                        bResumeWasAttempted = TRUE;
+                        bResumeOccurred = (HXR_OK == m_pHXPlayer->Begin());
+                        m_bPlayerIsPausedByThis = !bResumeOccurred;
+                    }
+                }
+            }
+        }
+    }
+
+    if (GetGlobal()->bEnableVerboseMode  &&  !m_bDownloadIsComplete)
+    {
+        STDOUT("\nDownload progress: (play time=%lu,",
+                ulCurPlayTime);
+        if (HX_PROGDOWNLD_UNKNOWN_TIME_SURPLUS == lTimeSurplus)
+        {
+            STDOUT(" UNKNOWN surplus|deficit)");
+        }
+        else if (HX_PROGDOWNLD_MIN_TIME_SURPLUS == lTimeSurplus)
+        {
+            STDOUT(" deficit exceeds maximum");
+        }
+        else if (HX_PROGDOWNLD_MAX_TIME_SURPLUS == lTimeSurplus)
+        {
+            STDOUT(" surplus exceeds maximum)");
+        }
+        else
+        {
+            STDOUT(" surplus=%ld milliseconds)", lTimeSurplus);
+        }
+        if (HX_PROGDOWNLD_UNKNOWN_DURATION == ulNewDurSoFar)
+        {
+            STDOUT("\n\thave UNKNOWN");
+        }
+        else
+        {
+            STDOUT("\n\thave %lu", ulNewDurSoFar);
+        }
+        
+        if (HX_PROGDOWNLD_UNKNOWN_DURATION != m_ulTotalDurReported)
+        {
+            STDOUT(" of %lu msec", m_ulTotalDurReported);
+        }
+        else
+        {
+            STDOUT(" of UNKNOWN msec of media");
+        }
+        if (HX_PROGDOWNLD_UNKNOWN_FILE_SIZE != ulNewBytesSoFar)
+        {
+            STDOUT(" (%lu", ulNewBytesSoFar);
+        }
+        else
+        {
+            STDOUT(" (UNKNOWN");
+        }
+        STDOUT(" bytes downloaded so far)\n", ulNewBytesSoFar);
+
+        if (bPauseOccurred  ||  bPauseWasAttempted)
+        {
+            STDOUT("# Waiting for more data: %splayback.\n "
+                    "    Should take %ld milliseconds before playback resumes.\n",
+                    bPauseOccurred? "Pausing " :
+                        (bPauseWasAttempted? "Failed attempting to pause "
+                                              : " "), -lTimeSurplus);
+        }
+        if (bResumeOccurred  ||  bResumeWasAttempted)
+        {
+            STDOUT("# Data available: %splayback\n "
+                    "    Time surplus is now %ld",
+                    bResumeOccurred? "Resuming " :
+                        (bResumeWasAttempted? "Failed attempting to resume "
+                                              : " "), lTimeSurplus);
+        }
+    }
+
+    m_bFirstPDStatusMessage = FALSE;
+
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXPDStatusObserver::OnTotalDurChanged
+ *  Purpose:
+ *      This is a notification if the total file duration becomes known
+ *      or becomes better-known during download/playback
+ *      
+ *      Note: pStreamSource can be NULL.  This will be true when
+ *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+ *      object.
+ */
+STDMETHODIMP
+ExamplePDStatusObserver::OnTotalDurChanged(
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource,
+            UINT32 ulNewTotalDur)
+{
+    m_ulTotalDurReported = ulNewTotalDur;
+
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("\nOnTotalDurChanged(): to %lu milliseconds\n", ulNewTotalDur);
+    }
+
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXPDStatusObserver::OnDownloadComplete
+ *
+ *  Purpose:
+ *      Notification that the entire file has been downloaded.
+ *
+ *      Note: pStreamSource can be NULL.  This will be true when
+ *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+ *      object.
+ *      
+ */
+STDMETHODIMP
+ExamplePDStatusObserver::OnDownloadComplete(
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource)
+{
+    m_bDownloadIsComplete = TRUE;
+
+    HXBOOL bResumeWasAttempted = FALSE;
+    HXBOOL bResumeOccurred = FALSE;
+
+    // /In case we're paused, resume now that there is no more data to get:
+    if (m_pHXPlayer  &&  m_bPlayerIsPausedByThis)
+    {
+        bResumeWasAttempted = TRUE;
+        bResumeOccurred = (HXR_OK == m_pHXPlayer->Begin());
+        m_bPlayerIsPausedByThis = !bResumeOccurred;
+    }
+    
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("\nOnDownloadComplete()\n");
+        if (bResumeOccurred  ||  bResumeWasAttempted)
+        {
+            STDOUT("\n%splayback now that bytes are available for "
+                    "uninterrupted playback\n",
+                    bResumeOccurred? "Resuming " :
+                        (bResumeWasAttempted? "Failed attempting to resume "
+                                              : " "));
+        }
+    }
+
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXPDStatusObserver::SrcClaimsSeekSupport         ref: hxprdnld.h
+ *  Purpose:
+ *      Passes along notification from file sys that seek support
+ *      is or is not claimed to be available (although sometimes HTTP
+ *      server claims this when it doesn't actually support it).
+ */
+STDMETHODIMP
+ExamplePDStatusObserver::SrcClaimsSeekSupport(IHXStreamSource* pStreamSource,
+                                              HXBOOL bClaimsSupport)
+{
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("\nSrcClaimsSeekSupport(%sE)\n", bClaimsSupport?"TRU":"FALS");
+    }
+    return HXR_OK;
+}
+
+
+/************************************************************************
+ *  Method:
+ *      IHXPDStatusObserver::OnDownloadPause
+ *  Purpose:
+ *      Notification that the file-download process has purposefully
+ *      and temporarily halted downloading of the file
+ *      
+ *      Note: pStreamSource can be NULL.  This will be true when
+ *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+ *      object.
+ */
+STDMETHODIMP
+ExamplePDStatusObserver::OnDownloadPause(
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource)
+{
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("\nOnDownloadPause()\n");
+    }
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *      IHXPDStatusObserver::OnDownloadResume
+ *  Purpose:
+ *      Notification that the file-download process has resumed
+ *      the process of downloading the remainder of the file
+ *      
+ *      Note: pStreamSource can be NULL.  This will be true when
+ *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+ *      object.
+ */
+STDMETHODIMP
+ExamplePDStatusObserver::OnDownloadResume(
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource)
+{
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("\nOnDownloadResume()\n");
+    }
+    return HXR_OK;
+}
+// /#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS.
Index: helix-libs/clientapps/clutter/exprdnld.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exprdnld.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,196 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXPRDNLD_H_
+#define _EXPRDNLD_H_
+
+// /#if defined(HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS)
+
+/****************************************************************************
+ * 
+ *  Class:
+ *
+ *	ExamplePDStatusObserver
+ *
+ *  Purpose:
+ *
+ *	Implementation for IHXPDStatusObserver which receives progressive-
+ *      download status reports:
+ *
+ */
+class ExamplePDStatusObserver : 
+	public IHXPDStatusObserver
+{
+private:
+    INT32		    m_lRefCount;
+    IHXPDStatusMgr*         m_pPrgDnldStatusMgr;
+    IUnknown*		    m_pUnkPlayer;
+    IHXPlayer*              m_pHXPlayer;
+    HXBOOL                  m_bPlayerIsPausedByThis;
+    HXBOOL                  m_bFirstPDStatusMessage;
+    UINT32                  m_ulTotalDurReported;
+    UINT32                  m_ulDurSoFar;
+    UINT32                  m_ulCurStatusUpdateGranularity;
+    HXBOOL                  m_bInitialPrerollUpateGranularitySet;
+    HXBOOL                  m_bDownloadIsComplete;
+
+    ExamplePDStatusObserver();
+    ~ExamplePDStatusObserver();
+
+public:
+    ExamplePDStatusObserver(IUnknown* pUnkPlayer);
+    
+    /*
+     * IUnknown methods
+     */
+    STDMETHOD(QueryInterface)	(THIS_
+				REFIID riid,
+				void** ppvObj);
+
+    STDMETHOD_(ULONG32,AddRef)	(THIS);
+
+    STDMETHOD_(ULONG32,Release)	(THIS);
+
+    /*
+     *  IHXPDStatusObserver methods
+     */
+
+    /************************************************************************
+     *  Method:
+     *      IHXPDStatusObserver::OnDownloadProgress
+     *
+     *  Purpose:
+     *      Notification from IHXPDStatusMgr of download progress when
+     *      file size changes.
+     *
+     *      lTimeSurplus:
+     *      - When negative, the absolute value of it is the estimated number
+     *      of milliseconds of wall-clock time that need to pass while
+     *      downloading continues before reaching the point at which playback
+     *      can resume and play the remainder of the stream without having to
+     *      buffer, assuming that playback is paused and remains so during
+     *      that period.
+     *      - When positive, it is the estimated number of milliseconds of
+     *      wall-clock time between when the download should complete and when
+     *      the natural content play-out duration will be reached, assuming
+     *      playback is currently progressing and that no pause will occur.
+     *
+     *      Note: ulNewDurSoFar can be HX_PROGDOWNLD_UNKNOWN_DURATION if the
+     *      IHXMediaBytesToMediaDurConverter was not available to, or was
+     *      unable to convert the bytes to a duration for the IHXPDStatusMgr
+     *      calling this:
+     */
+    STDMETHOD(OnDownloadProgress) (THIS_
+            IHXStreamSource* /*IN*/  /*NULL is valid value*/ pStreamSource,
+            UINT32 /*IN*/ ulNewDurSoFar,
+            UINT32 /*IN*/ ulNewBytesSoFar,
+            INT32  /*IN*/ lTimeSurplus);
+
+    /************************************************************************
+     *  Method:
+     *      IHXPDStatusObserver::OnTotalDurChanged
+     *  Purpose:
+     *      This is a notification if the total file duration becomes known
+     *      or becomes better-known during download/playback
+     *      
+     *      Note: pStreamSource can be NULL.  This will be true when
+     *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+     *      object.
+     */
+    STDMETHOD(OnTotalDurChanged)  (THIS_
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource,
+            UINT32 /*IN*/ ulNewDur);
+
+    /************************************************************************
+     *  Method:
+     *      IHXPDStatusObserver::OnDownloadComplete
+     *
+     *  Purpose:
+     *      Notification that the entire file has been downloaded.
+     *
+     *      Note: pStreamSource can be NULL.  This will be true when
+     *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+     *      object.
+     *      
+     */
+    STDMETHOD(OnDownloadComplete)    (THIS_
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource);
+
+    /************************************************************************
+     *  Method:
+     *      IHXPDStatusObserver::SrcClaimsSeekSupport
+     *
+     *  Purpose:
+     *      Passes along notification from file sys that seek support
+     *      is claimed to be available (although sometimes HTTP server
+     *      claims this when it doesn't actually support it).
+     *
+     */
+    STDMETHOD(SrcClaimsSeekSupport)    (THIS_
+            IHXStreamSource* pStreamSource,
+            HXBOOL /*IN*/ bSrcClaimsSeekSupport);
+
+    /************************************************************************
+     *  Method:
+     *      IHXPDStatusObserver::OnDownloadPause
+     *  Purpose:
+     *      Notification that the file-download process has purposefully
+     *      and temporarily halted downloading of the file
+     *      
+     *      Note: pStreamSource can be NULL.  This will be true when
+     *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+     *      object.
+     */
+    STDMETHOD(OnDownloadPause)    (THIS_
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource);
+
+    /************************************************************************
+     *  Method:
+     *      IHXPDStatusObserver::OnDownloadResume
+     *  Purpose:
+     *      Notification that the file-download process has resumed
+     *      the process of downloading the remainder of the file
+     *      
+     *      Note: pStreamSource can be NULL.  This will be true when
+     *      IHXPDStatusMgr calling this is upstream of the IHXStreamSource
+     *      object.
+     */
+    STDMETHOD(OnDownloadResume)    (THIS_
+            IHXStreamSource* /*IN*/ /*NULL is valid value*/ pStreamSource);
+};
+// /#endif // /HELIX_FEATURE_PROGRESSIVE_DOWNLD_STATUS.
+
+#endif // _EXPRDNLD_H_
+
Index: helix-libs/clientapps/clutter/exroot.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exroot.cpp	2008-10-13 06:54:08.000000000 -0700
@@ -0,0 +1,672 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: unixroot.cpp,v 1.9 2007/07/06 20:54:01 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+// for shared memory
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/utsname.h>
+
+#include "hxcom.h"
+#include "hxwintyp.h"
+#include "hxvsurf.h"
+#include "hxslist.h"
+#include "colormap.h"
+#include "hxprefs.h"
+#include "hxtick.h"
+#include "hxthread.h"
+#include "basesite.h"
+#include "exroot.h"
+#include "exsite.h"
+#include "unixcmap.h"
+#include "shmhelp.h"
+
+//  #ifdef _DEBUG
+//  #include <X11/extensions/xf86vmode.h> //for debug video sync rates..
+//  #endif
+
+//Work around AIX problem.
+#ifdef _AIX
+#  define MAX_SHARED_REGIONS ((UINT32)1)
+#else
+#  define MAX_SHARED_REGIONS ((UINT32)9999)
+#endif
+
+CExRootSurf::CExRootSurf(IUnknown* pContext, CHXBaseSite* pSite, on_new_frame_cb_t on_new_frame_cb, void *context )
+   : CBaseRootSurface(pContext, pSite)
+   , m_bUseShm(FALSE)
+   , m_nShmId(0)
+   , m_pDisplay(NULL)
+   , m_GC(0)
+   , m_nScreenNumber(0)
+   , m_pXImage(NULL)
+   , m_pVisual(NULL)
+   , m_unDepth(0)
+   , m_pScreen(NULL)
+   , m_pYUVScratchBits(NULL)
+   , m_nYUVScratchPitch(0)
+   , m_pScratchBits(NULL)
+   , m_nScratchPitch(0)
+   , m_nBitsPerPixel(0)
+   , m_nCompositionSize(0)
+   , m_on_new_frame_cb(on_new_frame_cb)
+   , m_context(context)
+{
+}
+
+HX_RESULT CExRootSurf::Init()
+{
+   //get window and display from main Site.
+   HXxWindow* pWindow = m_pSite->GetWindow();
+   HX_ASSERT(pWindow);
+
+   m_pDisplay = (Display*)pWindow->display;
+   m_window   = (Window)pWindow->window;
+
+   HX_ASSERT( m_pDisplay );
+   HX_ASSERT( m_window );
+
+   //
+   // Now see if our X11 server supports the Shared Memory extension.
+   //
+  // ShmHelp::Init(m_pDisplay);
+  // m_bUseShm = ShmHelp::ShmAvailable();
+
+   //Create the graphics context
+   XGCValues values;
+
+   XLockDisplay(m_pDisplay);
+   m_GC = XCreateGC(m_pDisplay, m_window, 0, &values);
+
+    //Get X window attributes & visual
+   XWindowAttributes attr;
+   XGetWindowAttributes(m_pDisplay, m_window, &attr);
+   XUnlockDisplay(m_pDisplay);
+   m_pVisual = attr.visual;
+
+   // get visual info & depth
+   int nv=0;
+   XVisualInfo visInfo;
+   memset(&visInfo, 0, sizeof(XVisualInfo));
+   XLockDisplay(m_pDisplay);
+   visInfo.visualid = XVisualIDFromVisual(m_pVisual);
+   XVisualInfo* pVisualInfo = XGetVisualInfo (m_pDisplay, VisualIDMask, &visInfo, &nv);
+//   m_unDepth       = pVisualInfo->depth;
+   m_unDepth       = 24;
+   m_nScreenNumber = DefaultScreen(m_pDisplay);
+   m_pScreen       = XScreenOfDisplay(m_pDisplay, m_nScreenNumber);
+   XUnlockDisplay(m_pDisplay);
+   m_colormap      = HXGetXColormap(m_pDisplay, m_window);
+
+   // get pixmap (blt) information for the best depth we can display
+   int i=0;
+   int nNum=0;
+   XLockDisplay(m_pDisplay);
+   XPixmapFormatValues *pixmap_formats = XListPixmapFormats(m_pDisplay, &nNum);
+   XUnlockDisplay(m_pDisplay);
+   if(pixmap_formats)
+   {
+      for (i=0 ; i<nNum; i++)
+      {
+         if (pixmap_formats[i].depth == m_unDepth)
+         {
+            m_nBitsPerPixel = pixmap_formats[i].bits_per_pixel;
+         }
+      }
+      XFree(pixmap_formats);
+      pixmap_formats = NULL;
+   }
+
+   memset(&m_bmiSave, 0, sizeof(HXBitmapInfo));
+#if 0
+   m_bmiSave.bmiHeader.biBitCount    = m_nBitsPerPixel;
+   m_bmiSave.bmiHeader.biCompression = (m_unDepth==8 ? BI_RGB : BI_BITFIELDS);
+   m_bmiSave.un.dwBitMask[0]         = pVisualInfo->red_mask;
+   m_bmiSave.un.dwBitMask[1]         = pVisualInfo->green_mask;
+   m_bmiSave.un.dwBitMask[2]         = pVisualInfo->blue_mask;
+#else
+   /* Fake a RGB24 */
+   m_nBitsPerPixel = 24;
+   m_bmiSave.bmiHeader.biBitCount    = m_nBitsPerPixel;
+   m_bmiSave.bmiHeader.biCompression = BI_RGB;
+#endif
+   //Set primary surface CID.
+   m_nCompositionSurfaceCID = GetBitmapColor(&m_bmiSave);
+   XFree( pVisualInfo );
+
+//  #ifdef _DEBUG
+//     //Lets find out what Hsync and Vsync rates we have for this display.
+//     //Ripped from xvidtune.c
+//     XF86VidModeModeLine mode_line;
+//     int    scrn=0;
+//     int    dot_clock;
+//     double vsync_hz, HSyncRate,HTotal, VTotal, PixelClock;
+//     if(XF86VidModeGetModeLine(m_pDisplay, scrn, &dot_clock, &mode_line))
+//     {
+//        PixelClock=dot_clock;
+//        HTotal = mode_line.htotal;
+//        VTotal = mode_line.vtotal;
+//        HSyncRate = PixelClock*1000.0/HTotal;
+//        vsync_hz = HSyncRate/VTotal;
+//        fprintf( stderr, "This Display's Hsync rate is: %f and Vsync: %f\n",
+//                 HSyncRate, vsync_hz );
+//     }
+
+//  #endif
+
+   return HXR_OK;
+}
+
+CExRootSurf::~CExRootSurf()
+{
+   _DestroyCompositionSurface();
+
+   if( m_GC )
+   {
+      XLockDisplay(m_pDisplay);
+      XFreeGC( m_pDisplay, m_GC );
+      XUnlockDisplay(m_pDisplay);
+      m_GC=0;
+   }
+   if (m_pVisual)
+   {
+      /* PJG: don't have to free visuals */
+      m_pVisual = NULL;
+   }
+
+   if(m_bUseShm)
+   {
+      if( m_pCompositionSurface != NULL )
+         ShmHelp::DetachSharedRegion(&m_pCompositionSurface, &m_shmInfo);
+   }
+   else
+   {
+      HX_DELETE(m_pCompositionSurface);
+      m_nCompositionSize=0;
+      m_bCompositionSurfaceCreated=FALSE;
+   }
+
+   //XXXgfw any more clean up for these two?
+   HX_VECTOR_DELETE( m_pScratchBits );
+   HX_VECTOR_DELETE( m_pYUVScratchBits );
+
+}
+
+HX_RESULT CExRootSurf::_ResizeVideoBuffer( INT32 nSize)
+{
+   HX_RESULT retVal=HXR_OK;
+
+   if(nSize <= m_nCompositionSize)
+      return retVal;
+
+   if(m_bUseShm)
+   {
+      if( m_pCompositionSurface != NULL )
+         retVal = ShmHelp::DetachSharedRegion(&m_pCompositionSurface, &m_shmInfo);
+      if( retVal==HXR_OK )
+      {
+         retVal = ShmHelp::CreateSharedRegion( nSize,
+                                               &m_pCompositionSurface,
+                                               &m_nShmId,
+                                               &m_shmInfo
+                                               );
+
+      }
+      if( retVal != HXR_OK )
+      {
+         m_bCompositionSurfaceCreated = FALSE;
+         m_nCompositionSize           = 0;
+         m_bUseShm = FALSE;
+      }
+      else
+      {
+         //It all worked
+         m_nCompositionSize           = nSize;
+         m_bCompositionSurfaceCreated = TRUE;
+         return retVal;
+      }
+
+   }
+
+   //We need to fall through here so that if the shared memory stuff
+   //above fails we can create it the old fashioned way.
+   if(m_pCompositionSurface == NULL)
+   {
+      m_pCompositionSurface = (UCHAR*) malloc(nSize);
+   }
+   else
+   {
+      m_pCompositionSurface = (UCHAR*) realloc(m_pCompositionSurface, nSize);
+   }
+   if( m_pCompositionSurface )
+   {
+      m_nCompositionSize = nSize;
+   }
+   else
+   {
+      HX_ASSERT("We can't alloc the composition surface." == NULL );
+      m_nCompositionSize = 0;
+   }
+
+   return retVal;
+}
+
+HX_RESULT CExRootSurf::_DebugBlt( UCHAR* pImageData, HXBitmapInfoHeader* pBitmapInfo,
+                     HXxRect& rDestRect, HXxRect& rSrcRect)
+{
+   HX_ASSERT( m_window );
+   HX_ASSERT( m_pDisplay );
+   HX_ASSERT( m_GC );
+   XLockDisplay(m_pDisplay);
+   XSetForeground( m_pDisplay, m_GC, WhitePixel(m_pDisplay, 0 ));
+   XSetBackground( m_pDisplay, m_GC, BlackPixel(m_pDisplay, 0 ));
+   XSetLineAttributes(m_pDisplay, m_GC, 5, LineSolid, CapRound, JoinRound );
+   XSetForeground( m_pDisplay, m_GC, WhitePixel(m_pDisplay, 0) );
+   XFillRectangle( m_pDisplay, m_window, m_GC,
+                   rDestRect.left, rDestRect.top,
+                   rDestRect.right-rDestRect.left,
+                   rDestRect.bottom-rDestRect.top
+                   );
+   XDrawRectangle( m_pDisplay, m_window, m_GC,
+                   rDestRect.left, rDestRect.top,
+                   rDestRect.right-rDestRect.left,
+                   rDestRect.bottom-rDestRect.top
+                   );
+   XUnlockDisplay(m_pDisplay);
+   return HXR_OK;
+}
+
+void CExRootSurf::_GetYUVScratchWidthHeight(UINT32* pWidth, UINT32* pHeight)
+{
+   *pWidth     = m_bmiYUVScratch.bmiHeader.biWidth;
+   *pHeight    = m_bmiYUVScratch.bmiHeader.biHeight;
+}
+
+XImage* CExRootSurf::_GetCompositionSurfaceDrawable()
+{
+   return m_pXImage;
+}
+
+
+
+//Not used except for XING.....
+void CExRootSurf::_CreateYUVScratchSurface(UINT32 width, UINT32 height)
+{
+   //Remove old bits....
+   HX_DELETE(m_pYUVScratchBits);
+
+   //Clear BitmapInfo struct....
+   memset(&m_bmiYUVScratch, 0, sizeof(HXBitmapInfo));
+   int nResult = MakeBitmap( &m_bmiYUVScratch,
+                             sizeof(m_bmiYUVScratch),
+                             CID_YUY2,
+                             width,
+                             height,
+                             NULL,
+                             0);
+   if( nResult )
+   {
+      m_pYUVScratchBits  = new UCHAR[m_bmiYUVScratch.bmiHeader.biSizeImage];
+      m_nYUVScratchPitch = GetBitmapPitch(&m_bmiYUVScratch);
+   }
+}
+
+
+void CExRootSurf::_GetYUVScratchSurfacePointer(UCHAR** pYUVBits, INT32* YUVPitch)
+{
+   *pYUVBits = m_pYUVScratchBits;
+   *YUVPitch = m_nYUVScratchPitch;
+}
+
+HX_RESULT CExRootSurf::CreateScratchSurface( int nCompositionSurfaceCID, HXxSize* pSize)
+{
+   //Remove old bits....
+   HX_DELETE(m_pScratchBits);
+
+   //Clear BitmapInfo struct....
+   memset(&m_bmiScratch, 0, sizeof(HXBitmapInfo));
+   int nResult = MakeBitmap( &m_bmiScratch,
+                             sizeof(m_bmiScratch),
+                             nCompositionSurfaceCID,
+                             pSize->cx,
+                             pSize->cy,
+                             NULL,
+                             0);
+   if( nResult )
+   {
+      m_pScratchBits  = new UCHAR[m_bmiScratch.bmiHeader.biSizeImage];
+      m_nScratchPitch = GetBitmapPitch(&m_bmiScratch);
+   }
+
+   return nResult? HXR_OK : HXR_FAIL;
+}
+
+HX_RESULT CExRootSurf::ScratchLock(UCHAR** pBits, INT32* pPitch)
+{
+   *pBits  = m_pScratchBits;
+   *pPitch = m_nScratchPitch;
+   return HXR_OK;
+}
+
+HX_RESULT CExRootSurf::ScratchUnlock(UCHAR* pBits)
+{
+   return HXR_OK;
+}
+
+HX_RESULT CExRootSurf::_MinimalUnlock(HXxWindow* pWindow)
+{
+//     Window win = m_window;
+//     HX_ASSERT(win);
+//     HXxSize hxxSize;
+//     m_pSite->GetSize(hxxSize);
+
+//     if (m_bUseShm)
+//     {
+//        XShmPutImage(m_pDisplay,
+//                     win,
+//                     m_GC,
+//                     m_pXImage,
+//                     0,
+//                     0,
+//                     0,
+//                     0,
+//                     hxxSize.cx,
+//                     hxxSize.cy,
+//                     False
+//                     );
+//     }
+//     else
+//     {
+//        XPutImage(m_pDisplay,
+//                  win,
+//                  m_GC,
+//                  m_pXImage,
+//                  0,
+//                  0,
+//                  0,
+//                  0,
+//                  hxxSize.cx,
+//                  hxxSize.cy
+//                  );
+//     }
+     return HXR_OK;
+}
+
+HX_RESULT CExRootSurf::_LockComposition(UCHAR** pBits, INT32* pPitch)
+{
+   HX_RESULT retVal = HXR_OK;
+   if( !m_bCompositionSurfaceCreated || m_pCompositionSurface==NULL )
+   {
+      retVal = _CreateCompositionSurface();
+   }
+   HX_ASSERT( m_pCompositionSurface );
+   *pBits  = m_pCompositionSurface;
+   *pPitch = m_nCompositionPitch;
+   return HXR_OK;
+}
+
+
+void CExRootSurf::_BltFromScratchToComposition( HXxRect& rDestRect, HXxRect& rSrcRect)
+{
+   HX_ASSERT( "Not implemented on unix yet...."==NULL );
+}
+
+HX_RESULT CExRootSurf::_CreateCompositionSurface()
+{
+   HX_RESULT retVal = HXR_FAIL;
+
+   if(m_bCompositionSurfaceCreated)
+   {
+      return HXR_OK;
+   }
+
+   HX_ASSERT( !m_bCompositionSurfaceCreated );
+   HX_ASSERT( m_pSite );
+
+   //Create a BMI to describe the composition surface
+   HXxSize hxxSize;
+   m_pSite->GetSize(hxxSize);
+   memcpy(&m_compositionSize, &hxxSize, sizeof(HXxSize)); /* Flawfinder: ignore */
+
+   // find out how big we want to allocate.
+   if (m_pSite->IsFullScreen())
+   {
+      UINT16 unDummy=0;
+      UINT16 unHorzRes=0;
+      UINT16 unVertRes=0;
+      m_pSite->_GetDeviceCaps(NULL, unDummy, unHorzRes, unVertRes );
+      m_allocatedCompositionSize.cx = unHorzRes;
+      m_allocatedCompositionSize.cy = unVertRes;
+   }
+   else
+   {
+        // we use root surface for BASIC_BLT and it assumes the offset(position) 
+        // of the root site it cooresponding to is (0, 0).
+        //
+        // this is not true for "windowless" mode where the root site can be given
+        // an offset, as a result, we fail to blt the video.
+        //
+        // to fix this, we'll take the m_positionOrg into consideration when
+        // creating the composition surface, this may not be optimal but good enough
+        // for now.
+        //
+        // similar logic is also added for other platforms, we need to move this
+        // common code to the base class when we have chance to clean it up
+        if (m_compositionSize.cx && m_compositionSize.cy)
+        {
+            m_compositionSize.cx += m_pSite->m_positionOrig.x;
+            m_compositionSize.cy += m_pSite->m_positionOrig.y;
+        }
+
+        m_allocatedCompositionSize.cx = m_compositionSize.cx;
+        m_allocatedCompositionSize.cy = m_compositionSize.cy;
+   }
+
+   //XXXgfw uhhhh, OK.
+   if( m_compositionSize.cx > m_allocatedCompositionSize.cx ||
+       m_compositionSize.cy > m_allocatedCompositionSize.cy )
+   {
+      m_allocatedCompositionSize.cx = m_compositionSize.cx;
+      m_allocatedCompositionSize.cy = m_compositionSize.cy;
+   }
+
+   //Make the bitmap header struct.
+   m_bmiComposition.bmiHeader.biBitCount    = m_bmiSave.bmiHeader.biBitCount;
+   m_bmiComposition.bmiHeader.biCompression = m_bmiSave.bmiHeader.biCompression;
+   m_bmiComposition.un.dwBitMask[0]         = m_bmiSave.un.dwBitMask[0];
+   m_bmiComposition.un.dwBitMask[1]         = m_bmiSave.un.dwBitMask[1];
+   m_bmiComposition.un.dwBitMask[2]         = m_bmiSave.un.dwBitMask[2];
+   int nResult = MakeBitmap( &m_bmiComposition,
+                             sizeof(m_bmiComposition),
+                             m_nCompositionSurfaceCID,
+                             m_allocatedCompositionSize.cx,
+                             m_allocatedCompositionSize.cy,
+                             NULL,
+                             0
+                             );
+   m_bmiComposition.bmiHeader.biBitCount    = m_bmiSave.bmiHeader.biBitCount;
+   m_bmiComposition.bmiHeader.biCompression = m_bmiSave.bmiHeader.biCompression;
+   m_bmiComposition.un.dwBitMask[0]         = m_bmiSave.un.dwBitMask[0];
+   m_bmiComposition.un.dwBitMask[1]         = m_bmiSave.un.dwBitMask[1];
+   m_bmiComposition.un.dwBitMask[2]         = m_bmiSave.un.dwBitMask[2];
+
+   //Now create the bits....
+   _ResizeVideoBuffer( m_bmiComposition.bmiHeader.biSizeImage );
+   m_nCompositionPitch = GetBitmapPitch( &m_bmiComposition );
+
+   if( m_pXImage )
+   {
+      XFree( m_pXImage );
+   }
+    
+   if( m_bUseShm )
+   {
+      XLockDisplay(m_pDisplay);
+      m_pXImage  = XShmCreateImage( m_pDisplay,
+                                    m_pVisual,
+                                    m_unDepth,
+                                    ZPixmap,
+                                    (char*)m_pCompositionSurface,
+                                    &m_shmInfo,
+                                    m_allocatedCompositionSize.cx,
+                                    m_allocatedCompositionSize.cy
+                                    );
+      XUnlockDisplay(m_pDisplay);
+   }
+   else
+   {
+      XLockDisplay(m_pDisplay);
+      m_pXImage  = XCreateImage( m_pDisplay,
+                                 m_pVisual,
+                                 m_unDepth,
+                                 ZPixmap,
+                                 0,
+                                 (char*)m_pCompositionSurface,
+                                 m_allocatedCompositionSize.cx,
+                                 m_allocatedCompositionSize.cy,
+                                 32,
+                                 0);
+      XUnlockDisplay(m_pDisplay);
+   }
+
+   if( m_pXImage )
+   {
+      m_bCompositionSurfaceCreated = TRUE;
+#ifdef _BIG_ENDIAN
+      m_pXImage->byte_order = MSBFirst;
+#else
+      m_pXImage->byte_order = LSBFirst;
+#endif
+      retVal = HXR_OK;
+   }
+   return retVal;
+}
+
+void CExRootSurf::_MinimalBlt(HXxRect& destRect)
+{
+    if (m_on_new_frame_cb) 
+    {
+	PlayerImgInfo Info;
+	Info.Rect.left = destRect.left;
+	Info.Rect.right = destRect.right;
+	Info.Rect.top = destRect.top;
+	Info.Rect.bottom = destRect.bottom;
+	Info.cx = m_allocatedCompositionSize.cx;
+	Info.cy = m_allocatedCompositionSize.cy; 
+	m_on_new_frame_cb(m_pCompositionSurface, 
+			  m_bmiComposition.bmiHeader.biSizeImage, 
+			  &Info, 
+			  m_context);
+    }
+}
+
+HX_RESULT CExRootSurf::_DestroyCompositionSurface()
+{
+   HX_RESULT retVal = HXR_OK;
+   if( m_bCompositionSurfaceCreated )
+   {
+      if( m_pXImage )
+      {
+         XFree(m_pXImage);
+         m_pXImage = NULL;
+      }
+      m_bCompositionSurfaceCreated = FALSE;
+   }
+
+   return retVal;
+}
+
+
+
+HX_RESULT CExRootSurf::BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo)
+{
+#ifdef _DEBUG
+   fprintf(stderr, "CExRootSurf::BeginOptimizedBlt Needs to be written\n" );
+#endif
+   return HXR_NOTIMPL;
+}
+
+HX_RESULT CExRootSurf::OptimizedBlt( UCHAR*   pImageBits,
+                                       HXxRect& rDestRect,
+                                       HXxRect& rSrcRect)
+{
+#ifdef _DEBUG
+   fprintf(stderr, "CExRootSurf::OptimizedBlt Needs to be written\n" );
+#endif
+   return HXR_NOTIMPL;
+}
+
+HX_RESULT CExRootSurf::EndOptimizedBlt(void)
+{
+#ifdef _DEBUG
+   fprintf(stderr, "CExRootSurf::EndOptimizedBlt Needs to be written\n" );
+#endif
+   return HXR_NOTIMPL;
+}
+
+HX_RESULT CExRootSurf::GetOptimizedFormat(HX_COMPRESSION_TYPE& ulType)
+{
+#ifdef _DEBUG
+   fprintf(stderr, "CExRootSurf::GetOptimizedFormat Needs to be written\n" );
+#endif
+   return HXR_NOTIMPL;
+}
+
+HX_RESULT CExRootSurf::GetPreferredFormat(HX_COMPRESSION_TYPE& ulType)
+{
+#ifdef _DEBUG
+   fprintf(stderr, "CExRootSurf::GetPreferredFormat Needs to be written\n" );
+#endif
+   return HXR_NOTIMPL;
+}
+
+GC CExRootSurf::GetGC()
+{
+   return m_GC;
+}
Index: helix-libs/clientapps/clutter/exroot.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exroot.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,155 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: unixroot.h,v 1.8 2007/07/06 20:54:05 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef _UNIXROOT_H
+#define _UNIXROOT_H
+
+#include "baseroot.h"
+#if defined(USE_XWINDOWS)
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/Intrinsic.h>
+#include <X11/extensions/XShm.h>
+#endif
+
+#include "player.h"
+
+class CExRootSurf : public CBaseRootSurface
+{
+public:
+   CExRootSurf(IUnknown* pContext, CHXBaseSite* pSite, on_new_frame_cb_t on_new_frame_cb = NULL, void *context = NULL);
+
+   //Helpers....
+   HX_RESULT Init();
+   GC        GetGC();
+
+   //public inherited stuff
+   virtual HX_RESULT CreateScratchSurface(int nCompositionSurfaceCID, 
+                                          HXxSize* pSize);
+   virtual HX_RESULT ScratchLock(UCHAR** pBits, INT32* pPitch);
+   virtual HX_RESULT ScratchUnlock(UCHAR* pBits);
+
+   virtual HX_RESULT BeginOptimizedBlt(HXBitmapInfoHeader* pBitmapInfo);
+   virtual HX_RESULT OptimizedBlt( UCHAR*   pImageBits,
+                                   HXxRect& rDestRect,
+                                   HXxRect& rSrcRect);
+   virtual HX_RESULT EndOptimizedBlt(void);
+   virtual HX_RESULT GetOptimizedFormat(HX_COMPRESSION_TYPE& ulType);
+   virtual HX_RESULT GetPreferredFormat(HX_COMPRESSION_TYPE& ulType);
+
+   XImage* _GetCompositionSurfaceDrawable();
+
+   //Shared Memory helper func for the basesurf to use.
+//     HX_RESULT _DetachSharedRegion();
+//     HX_RESULT _CreateSharedRegion(INT32 nSize);
+   
+protected:
+
+   //Smartly handle resizing of shm buffer.
+   HX_RESULT _ResizeVideoBuffer(INT32 nSize);
+
+   //Inherited from CBaseRootSurface....
+   virtual void _BltFromScratchToComposition(HXxRect& rDestRect,
+                                             HXxRect& rSrcRect);
+   virtual HX_RESULT _DebugBlt( UCHAR*               pImageData,
+                                HXBitmapInfoHeader* pBitmapInfo,
+                                HXxRect&             rDestRect,
+                                HXxRect&             rSrcRect);
+   virtual void _GetYUVScratchWidthHeight(UINT32* pWidth, UINT32* pHeight);
+   virtual void _CreateYUVScratchSurface(UINT32 width, UINT32 height);
+   virtual void _GetYUVScratchSurfacePointer(UCHAR** pYUVBits, INT32* YUVPitch);
+   virtual HX_RESULT _MinimalUnlock(HXxWindow* pWindow);
+   virtual HX_RESULT _LockComposition(UCHAR** pBits, INT32* pPitch);
+   virtual HX_RESULT _CreateCompositionSurface();
+   virtual HX_RESULT _DestroyCompositionSurface();
+   virtual void      _MinimalBlt(HXxRect& dest);
+
+   
+private:
+
+   virtual ~CExRootSurf();
+   
+   //Protect unintentional copy and default ctors.
+   CExRootSurf();
+   CExRootSurf( const CExRootSurf& );
+   CExRootSurf& operator=( const CExRootSurf& it );
+
+   //Shared memory members.
+   HXBOOL            m_bUseShm;
+   XShmSegmentInfo m_shmInfo;
+   int             m_nShmId;
+
+   //General display and GC stuff.
+   Display*     m_pDisplay;
+   GC           m_GC;
+   int          m_nScreenNumber;
+   XImage*      m_pXImage;
+   Window       m_window;
+   Visual*      m_pVisual;
+   unsigned int m_unDepth;
+   Screen*      m_pScreen;
+   Colormap     m_colormap;
+   int          m_nBitsPerPixel;
+
+   //Bitmap stuff.
+   UCHAR*         m_pYUVScratchBits;
+   HXBitmapInfo  m_bmiYUVScratch;
+   int            m_nYUVScratchPitch;
+   UCHAR*         m_pScratchBits;
+   HXBitmapInfo  m_bmiScratch;
+   int            m_nScratchPitch;
+   HXBitmapInfo  m_bmiSave;
+   ULONG32        m_nCompositionSize;
+   on_new_frame_cb_t m_on_new_frame_cb;
+   void *   m_context;
+};
+
+#endif
Index: helix-libs/clientapps/clutter/exsite.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exsite.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,2915 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: unixsite.cpp,v 1.18.2.6 2008/06/05 14:24:30 lovish Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ *                 Phil Dibowitz
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef _UNIX
+#error This is the UNIX platform specific implementation.
+#endif
+
+//
+// System includes...
+//
+#include <stdio.h>
+#include "hlxclib/string.h"
+#if defined(USE_XWINDOWS)
+#include <X11/Intrinsic.h>
+#include <X11/Shell.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+#include <X11/Xos.h>
+#include <X11/cursorfont.h>
+#include <X11/extensions/XShm.h>
+#endif
+
+
+//
+// RMA includes...
+//
+#include "hxcom.h"
+#include "hxcore.h"
+#include "hxevent.h"
+#include "hxwintyp.h"
+#include "hxwin.h"
+#include "hxsite2.h"
+#include "hxtypes.h"
+#include "exsite.h"
+#include "unixcmap.h"
+#include "visuals.h"
+#include "region.h"
+#include "basesurf.h"
+#include "exroot.h"
+#include "hxthread.h"
+#include "hxtick.h"
+#include "sitetext.h"
+
+#include "unixsurf.h"
+
+#include "hxprefs.h"
+
+//
+// Global & Static global/member data....
+//
+Display *CHXExSite::zm_display = NULL;
+static CHXMapPtrToPtr z_mapSiteToWindow;
+
+//
+// Scroll bar support
+//
+#define SCROLL_BAR_WIDTH 13        //Width of scroll bar.
+//#define _ARROWS_SIDE_BY_SIDE 1   //Regular or side by side arrows?
+
+
+
+
+//
+// CHXExSite only Methods...
+//
+CHXExSite::CHXExSite( IUnknown* pContext, IUnknown* pUnkOuter, INT32 lInitialZorder, on_new_frame_cb_t on_new_frame_cb, void *context)
+    : CHXBaseSite( pContext, pUnkOuter, lInitialZorder )
+    , m_pUnixEventHandler(NULL)
+    , m_ScrollHorizButtonL(0)
+    , m_ScrollHorizButtonR(0)
+    , m_ScrollVertButtonT(0)
+    , m_ScrollVertButtonB(0)
+    , m_winFullScreenWindow(0)
+    , m_winOldParent(0)
+    , m_bScrollingInProgress(FALSE)
+    , m_nScrollDir(0)
+    , m_bLastPointInSite(FALSE)
+    , m_bDamaged(FALSE)
+    , m_bIgnoreFocusOutInFS(FALSE)
+    , m_bReparent(FALSE)
+    , m_on_new_frame_cb(on_new_frame_cb)
+    , m_context(context)
+#if defined(HELIX_CONFIG_MOBLIN)
+    , m_pAttachWindowCallback(NULL)
+    , m_pForceRedrawCallback(NULL)
+#endif    
+{
+    m_ptScrollVertPosT.x   = m_ptScrollVertPosT.y   = 0;
+    m_ptScrollVertPosB.x   = m_ptScrollVertPosB.y   = 0;
+    m_ptScrollHorizPosR.x  = m_ptScrollHorizPosR.y  = 0;
+    m_ptScrollHorizPosL.x  = m_ptScrollHorizPosL.y  = 0;
+    m_ptFullScreenOffset.x = m_ptFullScreenOffset.y = 0;
+    memset( &m_PreFullScreenSize, 0, sizeof( m_PreFullScreenSize ) );
+
+    HX_ASSERT( m_pContext );
+
+    /* Replace m_pVideoSurface with my own */
+/*    HX_RELEASE(m_pVideoSurface);
+    m_pVideoSurface = new CUnixSurf(m_pContext, this);
+    HX_ASSERT( m_pVideoSurface );
+    m_pVideoSurface->InitSurface(m_pContext);
+    m_pVideoSurface->AddRef();
+*/
+    IHXPreferences* pPreferences = NULL;
+    if( m_pContext && HXR_OK == m_pContext->QueryInterface( IID_IHXPreferences, (void **) &pPreferences))
+    {
+        IHXBuffer *pBuffer = NULL;
+        pPreferences->ReadPref("IgnoreFocusOutInFS", pBuffer);
+        if(pBuffer)
+        {
+            m_bIgnoreFocusOutInFS = (::atoi((const char*)pBuffer->GetBuffer()) == 1);
+            HX_RELEASE(pBuffer);
+        }
+    }
+}
+
+CHXExSite::~CHXExSite()
+{
+#if defined(HELIX_CONFIG_MOBLIN)
+    RemovePendingCallback(m_pAttachWindowCallback);
+    HX_RELEASE(m_pAttachWindowCallback);
+	
+    RemovePendingCallback(m_pForceRedrawCallback);
+    HX_RELEASE(m_pForceRedrawCallback);	
+#endif	
+    void* pDummy;
+    if (z_mapSiteToWindow.Lookup((void*)this, pDummy))
+    {
+        z_mapSiteToWindow.RemoveKey((void*)this);
+    }
+
+    if( m_pUnixEventHandler )
+    {
+        m_pUnixEventHandler->CancelCallback();
+        HX_RELEASE(m_pUnixEventHandler);
+    }
+}
+
+HX_RESULT CHXExSite::_OpenXDisplay(char* pszDisplayString)
+{
+    HX_RESULT retVal = HXR_OK;
+
+    //Is the connection open already?
+    if( NULL==zm_display )
+    {
+        zm_display = XOpenDisplay(pszDisplayString);
+
+        //If you can't open the display your done.
+        if(NULL == zm_display )
+        {
+            HX_ASSERT("Can't open X Display..."==NULL);
+            retVal = HXR_FAIL;
+        }
+        else
+        {
+            HX_ASSERT(m_pScheduler);
+            if( m_pScheduler )
+            {
+                //UnixEventHandler scheduls itself for init callback
+                //in the ctor.
+                m_pUnixEventHandler = new UnixEventHandler(this);
+                m_pUnixEventHandler->AddRef();
+            }
+        }
+    }
+    return retVal;
+}
+
+Window CHXExSite::CreateXWindow( Window win )
+{
+    Window     parentWindow;
+    HXxWindow* pWindow = NULL;
+    //If parentWin is NULL then we belong to the root window.
+    if( win )
+    {
+        parentWindow = win;
+    }
+    else
+    {
+        HX_ASSERT(zm_display);
+        XLockDisplay(zm_display);
+        parentWindow = RootWindow(zm_display, DefaultScreen(zm_display));
+        XUnlockDisplay(zm_display);
+    }
+
+    //Find the best visual to use on this display.
+    Visual* visual = GetBestVisual(zm_display);
+
+    //Get the visual info.
+    int         nNotUsed=0;
+    XVisualInfo stVisInfo;
+
+    memset(&stVisInfo, 0, sizeof(XVisualInfo));
+    stVisInfo.visualid = XVisualIDFromVisual(visual);
+    XLockDisplay(zm_display);
+    XVisualInfo* pVisual = XGetVisualInfo( zm_display,
+                                           VisualIDMask,
+                                           &stVisInfo,
+                                           &nNotUsed );
+    XUnlockDisplay(zm_display);
+
+    // Set up attributes of the window.
+    int                  attrMask = CWBackPixel | CWBorderPixel;
+    XSetWindowAttributes attr;
+
+    memset(&attr, 0, sizeof(XSetWindowAttributes));
+    XLockDisplay(zm_display);
+    attr.background_pixel = BlackPixel(zm_display, DefaultScreen(zm_display));
+    attr.border_pixel     = BlackPixel(zm_display, DefaultScreen(zm_display));
+    XUnlockDisplay(zm_display);
+
+    //See if the default visaul of hte screen is the same one we Want
+    //to use. If not, create a new one and install it.
+    Colormap cmap;
+    XLockDisplay(zm_display);
+    Visual*  defVisual = DefaultVisual(zm_display, DefaultScreen(zm_display));
+    XUnlockDisplay(zm_display);
+    if( defVisual->visualid != stVisInfo.visualid )
+    {
+        //XXXgfw Are we leaking this colormap????
+        XLockDisplay(zm_display);
+        cmap = XCreateColormap(zm_display, parentWindow, visual, AllocNone);
+        XUnlockDisplay(zm_display);
+        attr.colormap = cmap;
+        attrMask |= CWColormap;
+    }
+
+    // Set the size/position of the window before creating.
+    XSizeHints size_hints;
+
+    size_hints.flags  = PPosition | PSize;
+    size_hints.x      = m_position.x;
+    size_hints.y      = m_position.y;
+    size_hints.width  = 1;
+    size_hints.height = 1;
+
+    //Create it.
+    XLockDisplay(zm_display);
+    Window window = XCreateWindow(zm_display,
+                                  parentWindow,
+                                  size_hints.x,
+                                  size_hints.y,
+                                  size_hints.width,
+                                  size_hints.height,
+                                  0,
+                                  pVisual->depth,
+                                  InputOutput,
+                                  visual,
+                                  attrMask,
+                                  &attr);
+    XUnlockDisplay(zm_display);
+    XFree(pVisual);
+
+    //Tell the WM about this window.
+#if 0
+    XSetStandardProperties( zm_display,
+                            window,
+                            "CHXExSite",
+                            "CHXExSite",
+                            None,
+                            NULL, 0,
+                            &size_hints
+                            );
+#endif
+
+    //Select all input events on the window since the other platforms
+    //we work with have no concept of event masks
+    XLockDisplay(zm_display);
+#if 0
+    int result = XSelectInput( zm_display, window,
+                               ButtonPressMask   | ButtonReleaseMask | KeyPressMask    |
+                               KeyReleaseMask    | EnterWindowMask   | LeaveWindowMask |
+                               PointerMotionMask | ButtonMotionMask  | KeymapStateMask |
+                               ExposureMask      | StructureNotifyMask | FocusChangeMask
+                               );
+#else
+    int result = XSelectInput( zm_display, window, 0 );
+
+
+#endif
+    XUnlockDisplay(zm_display);
+    if( BadWindow == result )
+    {
+#ifdef _DEBUG
+        fprintf( stderr, "Can select events.\n" );
+#endif
+    }
+
+    //Map the window.
+    XLockDisplay(zm_display);
+ /*   XMapWindow(zm_display, window);   */
+
+    //Flush event queue.
+    XFlush(zm_display);
+    XUnlockDisplay(zm_display);
+
+
+    return window;
+}
+
+void CHXExSite::_MapHorzScroll()
+{
+#if 0
+    if( GetWindow() && GetWindow()->display && m_ScrollHorizButtonL)
+    {
+        Display* pDis = (Display*)GetWindow()->display;
+        XLockDisplay(pDis);
+        XMapWindow( pDis, m_ScrollHorizButtonL );
+        XMapWindow( pDis, m_ScrollHorizButtonR );
+        XUnlockDisplay(pDis);
+    }
+    _DrawArrows();
+#endif
+}
+
+void CHXExSite::_MapVertScroll()
+{
+#if 0
+    if( GetWindow() && GetWindow()->display && m_ScrollVertButtonT)
+    {
+        Display* pDis = (Display*)GetWindow()->display;
+        XLockDisplay(pDis);
+        XMapWindow( pDis, m_ScrollVertButtonT );
+        XMapWindow( pDis, m_ScrollVertButtonB );
+        XUnlockDisplay(pDis);
+    }
+    _DrawArrows();
+#endif
+}
+
+void CHXExSite::_MapScrollButtons()
+{
+#if 0
+    _MapHorzScroll();
+    _MapVertScroll();
+#endif
+}
+
+void CHXExSite::_UnmapHorzScroll()
+{
+#if 0
+    HX_ASSERT( GetWindow() );
+    if( m_ScrollHorizButtonL && GetWindow()->display )
+    {
+        Display* pDis = (Display*)GetWindow()->display;
+        XLockDisplay(pDis);
+        XUnmapWindow( pDis, m_ScrollHorizButtonL );
+        XUnmapWindow( pDis, m_ScrollHorizButtonR );
+        XUnlockDisplay(pDis);
+    }
+#endif
+}
+void CHXExSite::_UnmapVertScroll()
+{
+#if 0
+    HX_ASSERT( GetWindow() );
+    if( m_ScrollVertButtonT && GetWindow()->display )
+    {
+        Display* pDis = (Display*)GetWindow()->display;
+        XLockDisplay(pDis);
+        XUnmapWindow( pDis, m_ScrollVertButtonT );
+        XUnmapWindow( pDis, m_ScrollVertButtonB );
+        XUnlockDisplay(pDis);
+    }
+#endif
+}
+
+void CHXExSite::_UnmapScrollButtons()
+{
+#if 0
+    if( GetWindow() )
+    {
+        _UnmapVertScroll();
+        _UnmapHorzScroll();
+    }
+#endif
+}
+
+void CHXExSite::_DestroyScrollButtons()
+{
+    HXxWindow* pWin = GetWindow();
+    Display*   pDis = (Display*)(pWin?pWin->display:NULL);
+
+    if( m_ScrollHorizButtonL && pDis )
+    {
+        XLockDisplay(pDis);
+        XDestroyWindow( pDis, m_ScrollHorizButtonL );
+        m_ScrollHorizButtonL = 0;
+        XDestroyWindow( pDis, m_ScrollHorizButtonR );
+        XUnlockDisplay(pDis);
+        m_ScrollHorizButtonR = 0;
+    }
+
+    if( m_ScrollVertButtonT && pDis)
+    {
+        XLockDisplay(pDis);
+        XDestroyWindow( pDis, m_ScrollVertButtonT );
+        m_ScrollVertButtonT = 0;
+        XDestroyWindow( pDis, m_ScrollVertButtonB );
+        XUnlockDisplay(pDis);
+        m_ScrollVertButtonB = 0;
+    }
+    m_ptScrollVertPosT.x = m_ptScrollVertPosT.y = 0;
+    m_ptScrollVertPosB.x = m_ptScrollVertPosB.y = 0;
+    m_ptScrollHorizPosR.x = m_ptScrollHorizPosR.y = 0;
+    m_ptScrollHorizPosL.x = m_ptScrollHorizPosL.y = 0;
+}
+
+void CHXExSite::_DrawArrows()
+{
+#if 0 //Paul Debug
+    //only do the work if our site is visible.
+    if( !IsSiteVisible() )
+        return;
+
+    //Draw an arrow on this window.
+    XPoint points[4];
+    int offset = SCROLL_BAR_WIDTH/10;
+    GC tmpGC;
+    XGCValues values;
+    Display* dis = (Display*)GetWindow()->display;
+
+    if( m_ScrollVertButtonB )
+    {
+        XLockDisplay(dis);
+        tmpGC = XCreateGC( dis, m_ScrollVertButtonB, 0, &values );
+        XUnlockDisplay(dis);
+    }
+    else if( m_ScrollHorizButtonL )
+    {
+        XLockDisplay(dis);
+        tmpGC = XCreateGC( dis, m_ScrollHorizButtonL, 0, &values );
+        XUnlockDisplay(dis);
+    }
+    else
+    {
+        //We don't have any scroll bars to draw....
+        return;
+    }
+
+
+    XLockDisplay(dis);
+    XSetForeground( dis, tmpGC, WhitePixel(dis, 0 ));
+    XSetBackground( dis, tmpGC, BlackPixel(dis, 0 ));
+    XUnlockDisplay(dis);
+    Colormap cmap = HXGetXColormap((Display*)GetWindow()->display,
+                                   (Window)GetWindow()->window);
+    XColor color;
+
+    memset(&color, 0, sizeof(XColor));
+    XLockDisplay(dis);
+    XParseColor(dis, cmap, "blue", &color);
+    XUnlockDisplay(dis);
+    HXFindBestXColor(dis, cmap, &color);
+    XLockDisplay(dis);
+    XSetForeground( dis, tmpGC, color.pixel);
+    XSetLineAttributes(dis, tmpGC, 1, LineSolid, CapRound, JoinRound );
+    XUnlockDisplay(dis);
+
+
+    //Draw up Vertical arrow.
+    if( m_ScrollVertButtonT )
+    {
+        points[0].x = offset;
+        points[0].y = SCROLL_BAR_WIDTH-offset;
+        points[1].x = SCROLL_BAR_WIDTH/2;
+        points[1].y = offset;
+        points[2].x = SCROLL_BAR_WIDTH-offset;
+        points[2].y = SCROLL_BAR_WIDTH-offset;
+        points[3].x = points[0].x;
+        points[3].y = points[0].y;
+        XLockDisplay(dis);
+        XFillPolygon( dis, m_ScrollVertButtonT, tmpGC, points, 4, Convex, CoordModeOrigin);
+        XUnlockDisplay(dis);
+    }
+
+    //Draw down Vertical arrow.
+    if( m_ScrollVertButtonB )
+    {
+        points[0].x = offset;
+        points[0].y = offset;
+        points[1].x = SCROLL_BAR_WIDTH-offset;
+        points[1].y = offset;
+        points[2].x = SCROLL_BAR_WIDTH/2;
+        points[2].y = SCROLL_BAR_WIDTH-offset;
+        points[3].x = points[0].x;
+        points[3].y = points[0].y;
+        XLockDisplay(dis);
+        XFillPolygon( dis, m_ScrollVertButtonB, tmpGC, points, 4, Convex, CoordModeOrigin);
+        XUnlockDisplay(dis);
+    }
+
+    //Draw Left Horizontal arrow.
+    if( m_ScrollHorizButtonL )
+    {
+        points[0].x = SCROLL_BAR_WIDTH-offset;
+        points[0].y = offset;
+        points[1].x = SCROLL_BAR_WIDTH-offset;
+        points[1].y = SCROLL_BAR_WIDTH-offset;
+        points[2].x = offset;
+        points[2].y = SCROLL_BAR_WIDTH/2;
+        points[3].x = points[0].x;
+        points[3].y = points[0].y;
+        XLockDisplay(dis);
+        XFillPolygon( dis, m_ScrollHorizButtonL, tmpGC, points, 4, Convex, CoordModeOrigin);
+        XUnlockDisplay(dis);
+    }
+
+    //Draw Right Horizontal arrow.
+    if( m_ScrollHorizButtonR )
+    {
+        points[0].x = offset;
+        points[0].y = SCROLL_BAR_WIDTH-offset;
+        points[1].x = offset;
+        points[1].y = offset;
+        points[2].x = SCROLL_BAR_WIDTH-offset;
+        points[2].y = SCROLL_BAR_WIDTH/2;
+        points[3].x = points[0].x;
+        points[3].y = points[0].y;
+        XLockDisplay(dis);
+        XFillPolygon( dis, m_ScrollHorizButtonR, tmpGC, points, 4, Convex, CoordModeOrigin);
+        XUnlockDisplay(dis);
+    }
+
+    //Free the GC and go.
+    XLockDisplay(dis);
+    XFreeGC( dis, tmpGC );
+    XUnlockDisplay(dis);
+#endif
+}
+
+HXBOOL CHXExSite::_InButton( HXxPoint& pt, int x, int y )
+{
+    HXBOOL retVal =FALSE;
+    if( x>= pt.x && x< pt.x+SCROLL_BAR_WIDTH && y>=pt.y && y<pt.y+SCROLL_BAR_WIDTH )
+        retVal=TRUE;
+    else
+        retVal=FALSE;
+
+    return retVal;
+}
+
+void CHXExSite::_CreateHorizScrollBar()
+{
+    HX_ASSERT( m_ScrollHorizButtonL == 0 );
+    HX_ASSERT( m_ScrollHorizButtonR == 0 );
+
+    HXxSize  mySize;
+
+    HXxWindow* pParentWindow = NULL;
+    if(GetParentSite())
+    {
+        pParentWindow = GetParentSite()->GetWindow();
+    }
+    if(pParentWindow)
+    {
+        GetParentSite()->GetSize(mySize);
+    }
+
+    HX_ASSERT( pParentWindow );
+    HX_ASSERT( pParentWindow->window != 0 );
+
+    if( m_ScrollVertButtonB )
+    {
+        // if the other bar already exists, don't overlap it!
+        mySize.cx -= SCROLL_BAR_WIDTH;
+    }
+
+    m_ptScrollHorizPosL.x = m_topleft.x;
+    m_ptScrollHorizPosL.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH;
+
+#ifndef _ARROWS_SIDE_BY_SIDE
+    m_ptScrollHorizPosR.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH;
+#else
+    m_ptScrollHorizPosR.x = m_topleft.x+SCROLL_BAR_WIDTH;
+#endif
+    m_ptScrollHorizPosR.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH;
+
+    Display* dis     = (Display*)GetWindow()->display;
+    XLockDisplay(dis);
+    Pixel blackPixel = BlackPixel( dis, DefaultScreen(dis) );
+    XUnlockDisplay(dis);
+    Pixel greyPixel  = blackPixel;
+
+    Colormap cmap = HXGetXColormap(dis, (Window)GetWindow()->window);
+    XColor color;
+
+    XLockDisplay(dis);
+    XParseColor(dis, cmap, "gray", &color);
+    XUnlockDisplay(dis);
+    HXFindBestXColor(dis, cmap, &color);
+    greyPixel = color.pixel;
+
+    XLockDisplay(dis);
+    m_ScrollHorizButtonL = XCreateSimpleWindow( dis,
+                                                (Window)pParentWindow->window,
+                                                m_ptScrollHorizPosL.x, m_ptScrollHorizPosL.y,
+                                                SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
+                                                1,
+                                                blackPixel,
+                                                greyPixel
+                                                );
+    m_ScrollHorizButtonR = XCreateSimpleWindow( dis,
+                                                (Window)pParentWindow->window,
+                                                m_ptScrollHorizPosR.x, m_ptScrollHorizPosR.y,
+                                                SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
+                                                1,
+                                                blackPixel,
+                                                greyPixel
+                                                );
+    XUnlockDisplay(dis);
+    HX_ASSERT( m_ScrollHorizButtonR && m_ScrollHorizButtonL );
+
+}
+
+void CHXExSite::_CreateVertScrollBar()
+{
+    HX_ASSERT( m_ScrollVertButtonB == 0 );
+    HX_ASSERT( m_ScrollVertButtonT == 0 );
+
+    HXxSize  mySize;
+
+    HXxWindow* pParentWindow = NULL;
+    if(GetParentSite())
+    {
+        pParentWindow = GetParentSite()->GetWindow();
+    }
+    if(pParentWindow)
+    {
+        GetParentSite()->GetSize(mySize);
+    }
+
+    HX_ASSERT( pParentWindow );
+    HX_ASSERT( pParentWindow->window != 0 );
+
+    if( m_ScrollHorizButtonR )
+    {
+        // if the other bar already exists, don't overlap it!
+        mySize.cy -= SCROLL_BAR_WIDTH;
+    }
+
+
+    m_ptScrollVertPosT.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH;
+    m_ptScrollVertPosT.y = m_topleft.y;
+
+    m_ptScrollVertPosB.x = m_topleft.x+mySize.cx-SCROLL_BAR_WIDTH;
+#ifndef _ARROWS_SIDE_BY_SIDE
+    m_ptScrollVertPosB.y = m_topleft.y+mySize.cy-SCROLL_BAR_WIDTH;
+#else
+    m_ptScrollVertPosB.y = m_topleft.y+SCROLL_BAR_WIDTH;
+#endif
+
+    Display* dis     = (Display*)GetWindow()->display;
+    XLockDisplay(dis);
+    Pixel blackPixel = BlackPixel( dis, DefaultScreen(dis) );
+    XUnlockDisplay(dis);
+    Pixel greyPixel  = blackPixel;
+    Colormap cmap = HXGetXColormap((Display*)GetWindow()->display,
+                                   (Window)GetWindow()->window);
+    XColor color;
+    XLockDisplay(dis);
+    XParseColor(dis, cmap, "gray", &color);
+    XUnlockDisplay(dis);
+    HXFindBestXColor(dis, cmap, &color);
+    greyPixel = color.pixel;
+
+    HX_ASSERT( GetWindow() );
+    XLockDisplay(dis);
+    m_ScrollVertButtonT = XCreateSimpleWindow( dis,
+                                               (Window)pParentWindow->window,
+                                               m_ptScrollVertPosT.x, m_ptScrollVertPosT.y,
+                                               SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
+                                               1,
+                                               blackPixel,
+                                               greyPixel
+                                               );
+    m_ScrollVertButtonB = XCreateSimpleWindow( dis,
+                                               (Window)pParentWindow->window,
+                                               m_ptScrollVertPosB.x, m_ptScrollVertPosB.y,
+                                               SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH,
+                                               1,
+                                               blackPixel,
+                                               greyPixel
+                                               );
+    XUnlockDisplay(dis);
+
+    HX_ASSERT( m_ScrollVertButtonB && m_ScrollVertButtonT );
+
+}
+
+//
+// Inherited CHXBaseSite methods.
+//
+void CHXExSite::_NeedWindowedSite()
+{
+#ifdef _DEBUG
+    fprintf( stderr, "CHXExSite::_NeedWindowedSite do something here....\n" );
+#endif
+    //Nothing to do on unix....
+}
+
+void CHXExSite::_AttachWindow()
+{
+#if 1
+    void* pDummy=NULL;
+
+    if (m_pRootSurface)
+    {	/* Replace CUnixRootSurf with my own CExRootSurf */
+	    HX_RELEASE(m_pRootSurface);
+	    m_pRootSurface = new CExRootSurf(m_pContext, this, m_on_new_frame_cb, m_context);
+	    m_pRootSurface->AddRef();
+    }
+
+    if(!z_mapSiteToWindow.Lookup((void*)this, pDummy))
+    {
+        z_mapSiteToWindow.SetAt((void*)this, (void*)m_pWindow);
+    }
+
+    //Set the display variable.
+    if( m_pWindow->display == NULL )
+    {
+        HX_ASSERT(zm_display);
+        m_pWindow->display = zm_display;
+    }
+
+    //Now that we have a window be sure to init the CExRootSurf.
+    //this lets it set up the display, colormap, etc.
+    ((CExRootSurf*)m_pRootSurface)->Init();
+#endif
+}
+
+void CHXExSite::_DetachWindow()
+{
+#if 1
+    void* pDummy;
+
+    if (z_mapSiteToWindow.Lookup((void*)this, pDummy))
+    {
+        z_mapSiteToWindow.RemoveKey((void*)this);
+    }
+#endif
+}
+
+void* CHXExSite::_Create(void* pParentWindow, UINT32 style)
+{
+    HRESULT result = HXR_OK;
+    if( m_pWindow && m_pWindow->window )
+    {
+        HX_ASSERT( "We already have created a window"==NULL);
+        return NULL;
+    }
+
+    if (pParentWindow==NULL || style)
+    {
+        m_bIsChildWindow = FALSE;
+    }
+    else
+    {
+        m_bIsChildWindow = TRUE;
+    }
+
+    if( _OpenXDisplay(NULL) != HXR_OK )
+    {
+        return NULL;
+    }
+    return (void*)CreateXWindow((Window)pParentWindow);
+}
+
+
+void CHXExSite::_Destroy(HXxWindow* pWindow)
+{
+    _DestroySliders();
+    HXxWindow* pWin = GetWindow();
+    Display*   pDis = (Display*)(pWin?pWin->display:NULL);
+    if( pDis )
+    {
+        XLockDisplay(pDis);
+        XDestroyWindow( pDis, (Window)pWindow->window );
+        XUnlockDisplay(pDis);
+    }
+}
+
+void CHXExSite::_SetSize(HXxSize size)
+{
+    HX_ASSERT( m_pWindow && m_pWindow->display && m_pWindow->window);
+    //The scroll bars get resized also...
+    _DestroySliders();
+    Display* pDis = (Display*)GetWindow()->display;
+    XLockDisplay(pDis);
+    XResizeWindow(pDis,
+                  (Window) m_pWindow->window,
+                  size.cx,
+                  size.cy);
+    XUnlockDisplay(pDis);
+}
+
+void CHXExSite::_SetPosition(HXxPoint position)
+{
+    HX_ASSERT( m_pWindow && m_pWindow->display && m_pWindow->window);
+    _DestroyScrollButtons();
+    XLockDisplay((Display*) m_pWindow->display);
+    XMoveWindow((Display*)m_pWindow->display,
+                (Window)m_pWindow->window,
+                position.x,
+                position.y);
+    XUnlockDisplay((Display*) m_pWindow->display);
+}
+
+void CHXExSite::_DamageRect(HXxRect rect)
+{
+    if(GetWindow())
+    {
+        m_bDamaged = TRUE;
+    }
+    return;
+}
+
+void CHXExSite::_DamageRegion(HXxRegion rect)
+{
+    if(GetWindow())
+    {
+        m_bDamaged = TRUE;
+    }
+    return;
+}
+
+void CHXExSite::_SendOSUpdateMessage()
+{
+    //We need to redraw our window here, m_pWindow.
+}
+
+void CHXExSite::_ShowSite(HXBOOL bShow)
+{
+    if( bShow )
+    {
+        _MapScrollButtons();
+    }
+    else
+    {
+        _UnmapScrollButtons();
+    }
+    //do nothing....
+}
+
+HXBOOL CHXExSite::_AtSystemTime()
+{
+    return TRUE;
+}
+
+void CHXExSite::_GetDeviceCaps( void* hdc,
+                                  UINT16& uBitsPerPixel,
+                                  UINT16& uHorzRes,
+                                  UINT16& uVertRes )
+{
+    Screen* pScreen = NULL;
+    HXxWindow* pWin = GetWindow();
+    HX_ASSERT( pWin );
+    if( pWin )
+    {
+        Display* dis = (Display*)pWin->display;
+        HX_ASSERT( dis );
+        if( dis )
+        {
+            Display* pDisp = (Display*)GetWindow()->display;
+            XLockDisplay(pDisp);
+            pScreen = DefaultScreenOfDisplay(pDisp);
+            XUnlockDisplay(pDisp);
+
+            uBitsPerPixel = pScreen->root_depth;
+            uHorzRes      = pScreen->width;
+            uVertRes      = pScreen->height;
+        }
+    }
+}
+
+void CHXExSite::_GetWindowRect(HXxRect* destRect)
+{
+    HX_ASSERT( "Doesn't seem to be used anywhere"==NULL );
+}
+
+void CHXExSite::_DestroySliders()
+{
+    _DestroyScrollButtons();
+}
+
+void CHXExSite::_ForwardUpdateEvent(HXxEvent* pEvent)
+{
+    GC gc = NULL;
+    AddRef();
+
+    HX_ASSERT(GetWindow()->window);
+    HX_ASSERT(m_pUser);
+    if(m_bIsChildWindow)
+    {
+        //Create a clip region that excludes our higher z-order
+        //siblings and is clipped to our parent.
+        if( !m_bRegionIsValid )
+        {
+            RecomputeClip();
+        }
+
+        // The problem is that regions are locked to the origin so we
+        // will need to reverse shift the region before we set the
+        // origin of the graph port! get the GC from the video surface
+        gc = ((CExRootSurf*)m_pRootSurface)->GetGC();
+        HX_ASSERT( gc );
+
+        //Actually setup our clip region
+        Display* pDis = (Display*)GetWindow()->display;
+        XLockDisplay(pDis);
+        XSetRegion( pDis, gc, (Region) m_Region );
+        XUnlockDisplay(pDis);
+    }
+
+    XEvent* pXEvent = (XEvent*) pEvent->param2;
+    XExposeEvent* exposeEvent = (XExposeEvent*) pXEvent;
+
+    // get the rect for this site with respect to our parent
+    HXRECTANGLE exposedRect = { exposeEvent->x,
+                                exposeEvent->y,
+                                exposeEvent->width,
+                                exposeEvent->height };
+    HXREGION* exposedRegion = HXCreateRegion();
+    HXUnionRectWithRegion(&exposedRect, exposedRegion,  exposedRegion);
+
+    // does the site intersect the current clipping region?
+    HXREGION* resultRegion = HXCreateRegion();
+    HXIntersectRegion(exposedRegion, m_Region, resultRegion);
+    HXBOOL bSiteIntersectsExposed = (HXEmptyRegion(resultRegion)==FALSE);
+
+    HXDestroyRegion(resultRegion);
+    HXDestroyRegion(exposedRegion);
+
+    // if the exposed region intersects the sites clipping region
+    if(bSiteIntersectsExposed)
+    {
+        m_pUser->HandleEvent(pEvent);
+    }
+
+    //If the user doesn't handle the standard update event then send
+    //them the cross platform HX_SURFACE_UPDATE event don't damage the
+    //original event structure
+    if(!pEvent->handled && m_pUser )
+    {
+        HX_ASSERT(GetWindow());
+        HXxEvent event;
+        event.event   = HX_SURFACE_UPDATE;
+        event.window  = GetWindow()->window;
+        event.param1  = m_pVideoSurface;
+        event.param2  = GetWindow();
+        event.result  = 0;
+        event.handled = FALSE;
+        m_pUser->HandleEvent(&event);
+        pEvent->handled = event.handled;
+    }
+
+
+    //reset the gc to use no region
+    if(m_bIsChildWindow && gc)
+    {
+        Display* pDisp = (Display*)GetWindow()->display;
+        XLockDisplay(pDisp);
+        XSetClipMask(pDisp, gc, None);
+        XUnlockDisplay(pDisp);
+    }
+
+    //Handle the drawing of our arrows...
+    _DrawArrows();
+
+    //Now do all our children....
+    CHXMapPtrToPtr::Iterator i = m_ChildrenMap.Begin();
+    for(;i!=m_ChildrenMap.End();++i)
+    {
+        CHXExSite* pSite = (CHXExSite*) *i;
+        pSite->_ForwardUpdateEvent(pEvent);
+    }
+
+    Release();
+}
+
+UINT32 CHXExSite::_MapKeySymToHXVK(KeySym sym, UINT32& uFlags )
+{
+    //XXXgfw if we add the extended flag in the HX_KEYBOARD event
+    //structure then we can modify the flags here to show that these
+    //keys are 'extended' in the windows sense.
+    UINT32 ulRet = 0;
+    switch( sym )
+    {
+       case XK_Shift_R:
+           ulRet = XK_Shift_L;
+           break;
+       case XK_Alt_R:
+           ulRet = XK_Alt_L;
+           break;
+       case XK_KP_Home:
+           ulRet = XK_Home;
+           break;
+       case XK_KP_Next:
+           ulRet = XK_Next;
+           break;
+       case XK_KP_Prior:
+           ulRet = XK_Prior;
+           break;
+       case XK_KP_Enter:
+           ulRet = XK_Return;
+           break;
+       case XK_KP_End:
+           ulRet = XK_End;
+           break;
+       case XK_KP_Begin:
+           ulRet = XK_Begin;
+           break;
+       case XK_KP_Left:
+           ulRet = XK_Left;
+           break;
+       case XK_KP_Up:
+           ulRet = XK_Up;
+           break;
+       case XK_Control_R:
+           ulRet = XK_Control_L;
+           break;
+       case XK_KP_Right:
+           ulRet = XK_Right;
+           break;
+       case XK_KP_Down:
+           ulRet = XK_Down;
+           break;
+       case XK_KP_Insert:
+           ulRet = XK_Insert;
+           break;
+       case XK_KP_Delete:
+           ulRet = XK_Delete;
+           break;
+       default:
+           ulRet = sym;
+           break;
+    }
+    if( ulRet != sym )
+    {
+        //We have mapped a key from Right hand side, keypad, arrows
+        //or other parts of an extended keyboard. Set the flag.
+        uFlags |= HX_EXTENDED_KEY_MASK;
+    }
+    return ulRet;
+}
+
+
+HXBOOL CHXExSite::_ConvertToHXEvent(HXxEvent* pEvent )
+{
+    // get original events info from pEvent
+    XEvent* pXEvent = (XEvent*) pEvent->param2;
+    XButtonEvent* buttonEvent = (XButtonEvent*) pXEvent;
+
+
+    //===============================================================
+    //   Convert all other event to RMA generic events and pass back.
+    //===============================================================
+    if( ((pEvent->event == ButtonPress)   ||
+         (pEvent->event == ButtonRelease) ||
+         (pEvent->event == MotionNotify ) ||
+         (pEvent->event == EnterNotify)   ||
+         (pEvent->event == FocusIn)       ||
+         (pEvent->event == FocusOut)      ||
+         (pEvent->event == KeyPress)      ||
+         (pEvent->event == KeyRelease)    ||
+         (pEvent->event == LeaveNotify))
+        )
+    {
+        // set modifier flags for all events....
+        UINT32 flags = 0;
+
+        // create new HXxEvent
+        HXxEvent theEvent;
+
+        //XXXgfw ouch....
+        static HXxPoint realPt = {0,0};
+
+        //Init certain members.
+        memset(&theEvent, 0, sizeof(HXxEvent));
+        theEvent.window  = pEvent->window;
+        theEvent.handled = FALSE;
+
+        //
+        // NOTE:
+        //
+        // theEvent must be filled in by *ALL* event types.
+        // theEvent will be memcopied into the pEvent passed
+        // back to the basesite at the end of the method.
+        //
+
+        //==================================================
+        // LEAVE NOTIFY EVENT
+        //==================================================
+        if( pEvent->event==LeaveNotify)
+        {
+            if( m_pTopLevelSite->m_pMouseInSite )
+            {
+                HXxPoint oobPoint;
+                oobPoint.x = -1;
+                oobPoint.y = -1;
+                HXxEvent Outevent = { HX_MOUSE_LEAVE,
+                                      m_pWindow->window,
+                                      (void*)&oobPoint,
+                                      0, 0,
+                                      FALSE };
+                m_pTopLevelSite->m_pMouseInSite->EventOccurred(&Outevent);
+                m_pTopLevelSite->m_pMouseInSite = NULL;
+            }
+            pEvent->handled=TRUE;
+            return TRUE;
+        }
+
+        //==================================================
+        // ENTER NOTIFY EVENT
+        //==================================================
+        if( pEvent->event==EnterNotify)
+        {
+            pEvent->handled=TRUE;
+            return TRUE;
+        }
+
+        //==================================================
+        // KEY PRESS/RELEASE EVENT
+        //==================================================
+        if ( pEvent->event == KeyPress || pEvent->event==KeyRelease )
+        {
+            XKeyEvent* pKeyEvent = (XKeyEvent*)pEvent->param2;
+
+            //
+            //Set the event type
+            //
+            theEvent.event = pEvent->event==KeyPress?HX_KEY_DOWN:HX_KEY_UP;
+
+            //
+            // Fill in the scan/key code.
+            //
+            flags =  pKeyEvent->keycode;
+            flags &= 0x000000ff; //the scan code only gets bits 0-7
+
+            //
+            // build key modifier list...
+            //
+            if( pKeyEvent->state & ShiftMask )
+                flags |= HX_SHIFT_MASK;
+
+            if( pKeyEvent->state & ControlMask )
+                flags |= HX_CTRL_MASK;
+
+            if( pKeyEvent->state & LockMask )
+                flags |= HX_CAPS_LOCK_MASK;
+
+            if( pKeyEvent->state & Mod1Mask)
+                flags |= HX_ALT_MASK;
+
+            if( pKeyEvent->state & Mod2Mask)
+                flags |= HX_NUM_LOCK_MASK;
+
+            if( pKeyEvent->state & Mod5Mask)
+                flags |= HX_SCROLL_LOCK_MASK;
+
+            //
+            //Store the char pressed.
+            //
+            KeySym sym;
+            char   szBuf[10]; /* Flawfinder: ignore */
+            int    nNum;
+
+            //Save the state of the keys...
+            unsigned int unSave = pKeyEvent->state;
+            pKeyEvent->state=0;
+
+            //Lookup the key without any state.
+            nNum = XLookupString( pKeyEvent, szBuf, 10, &sym, NULL );
+            if( nNum > 0 )
+            {
+                theEvent.param1 = (void*)*szBuf;
+            }
+            else
+            {
+                theEvent.param1 = (void*)_MapKeySymToHXVK(sym, flags);
+                flags |= HX_VIRTUAL_KEY_MASK;
+            }
+            //restore the state of the event
+            pKeyEvent->state = unSave;
+
+            //Set the flags...
+            theEvent.param2 = (void*)flags;
+
+            //Check for HX_CHAR needed or not.
+            if( theEvent.event == HX_KEY_DOWN )
+            {
+                //We have to send an extra HX_CHAR event
+                HXxEvent extraEvent;
+                memcpy( &extraEvent, &theEvent, sizeof( extraEvent ) ); /* Flawfinder: ignore */
+
+                //Change the type.
+                extraEvent.event = HX_CHAR;
+
+                //
+                //Change the keycode to an translated ascii char.
+                //
+                KeySym sym;
+                char   szBuf[10]; /* Flawfinder: ignore */
+                int    nNum;
+
+                nNum = XLookupString( pKeyEvent, szBuf, 10, &sym, NULL );
+
+                if( nNum > 0 )
+                {
+                    extraEvent.param1 = (void*)*szBuf;
+                }
+                else
+                {
+                    extraEvent.param1 = (void*)_MapKeySymToHXVK(sym, flags);
+                    flags |= HX_VIRTUAL_KEY_MASK;
+                }
+                extraEvent.param2 = (void*)flags;
+
+                //
+                // Now send the extra event....
+                //
+                CHXBaseSite::EventOccurred(&extraEvent);
+            }
+        }
+
+        //==================================================
+        // FOCUS OUT EVENT
+        //==================================================
+        if ( pEvent->event == FocusOut )
+        {
+            theEvent.event = HX_LOSE_FOCUS;
+        }
+
+        if ( pEvent->event == FocusIn )
+        {
+            theEvent.event = HX_SET_FOCUS;
+        }
+
+        //==================================================
+        // MOUSE MOVE EVENT
+        //==================================================
+        if( pEvent->event == MotionNotify )
+        {
+            XMotionEvent* pp = (XMotionEvent*)pEvent->param2;
+            theEvent.event = HX_MOUSE_MOVE;
+
+            if( pp->state&Button1Mask )
+                flags |= HX_PRIMARY_BUTTON;
+
+            if( pp->state&Button2Mask )
+                flags |= HX_CONTEXT_BUTTON;
+
+            if( pp->state&Button3Mask )
+                flags |= HX_THIRD_BUTTON;
+
+            if(pp->state & ShiftMask)
+                flags |= HX_SHIFT_KEY;
+
+            if(pp->state & ControlMask)
+                flags |= HX_CTRL_KEY;
+
+            if(pp->state & Mod1Mask)
+                flags |= HX_ALT_COMMAND_KEY;
+
+            theEvent.param2 = (void*) flags;
+
+            //Grab the X and Y.
+            theEvent.param1 = (void*) &realPt;
+            realPt.x = pp->x;
+            realPt.y = pp->y;
+        }
+
+        //==================================================
+        // BUTTON PRESS/RELEASE EVENT
+        //==================================================
+        if((pEvent->event == ButtonPress) || (pEvent->event == ButtonRelease))
+        {
+            // remap event
+            if (pEvent->event == ButtonPress)
+            {
+                if (buttonEvent->button == Button3)
+                    theEvent.event = HX_CONTEXT_BUTTON_DOWN;
+                else
+                    theEvent.event = HX_PRIMARY_BUTTON_DOWN;
+            }
+            else if (pEvent->event == ButtonRelease)
+            {
+                if (buttonEvent->button == Button3)
+                    theEvent.event = HX_CONTEXT_BUTTON_UP;
+                else
+                    theEvent.event = HX_PRIMARY_BUTTON_UP;
+            }
+
+            if(buttonEvent->state & ShiftMask)
+                flags |= HX_SHIFT_KEY;
+
+            if(buttonEvent->state & ControlMask)
+                flags |= HX_CTRL_KEY;
+
+            theEvent.param2 = (void*) flags;
+
+            //Grab the X and Y.
+            theEvent.param1 = (void*) &realPt;
+            realPt.x = buttonEvent->x;
+            realPt.y = buttonEvent->y;
+        }
+
+        //Copy the new event back into the passed in one for
+        //all events that fall through here...
+        memcpy( pEvent, &theEvent, sizeof(HXxEvent) ); /* Flawfinder: ignore */
+
+#if defined(_DEBUG)
+        //If the users presses control-primary button
+        //dump info on all sites. If shift-context, then
+        //just this site.
+        if( (buttonEvent->state&ControlMask)&&
+            (theEvent.event==HX_PRIMARY_BUTTON_DOWN))
+        {
+            DisplayAllSiteData();
+        }
+        if( (buttonEvent->state&ShiftMask)&&
+            (theEvent.event==HX_PRIMARY_BUTTON_DOWN))
+        {
+            DisplaySiteData("");
+        }
+#endif
+    }
+    return pEvent->handled;
+}
+
+
+void CHXExSite::CheckColorSettings()
+{
+#if !defined(HELIX_FEATURE_HARDWARE_COLOR_CONTROLS)
+    CHXBaseSite::CheckColorSettings();
+#else
+    CUnixSurf* pSurf = (CUnixSurf*)m_pVideoSurface;
+    if( !pSurf->HasHWColorConrols() )
+    {
+        CHXBaseSite::CheckColorSettings();
+    }
+    else
+    {
+        pSurf->SetHWColorControls();
+        
+        //We do all color stuff except sharpmess in hardware.
+        float fCurrentSharpness;
+        INT16 bInterpolate;
+        zm_pColorAcc->GetSharpnessAdjustments(&fCurrentSharpness, &bInterpolate);
+        
+        if (fCurrentSharpness != m_fSharpness)
+        {
+            zm_pColorAcc->SetSharpnessAdjustments(m_fSharpness, FALSE);
+        }
+    }
+#endif
+}
+
+//
+// OK, here it is. Take care of any OS specific duties, like scrollbar
+// stuff and expose events. Then, if the event isn't handled, convert
+// to an RMA event and return.
+HXBOOL CHXExSite::_HandleOSEvents(HXxEvent* pEvent)
+{
+    HXxPoint position = {0, 0};
+    HXxPoint point;
+
+    if( NULL==pEvent )
+    {
+        return FALSE;
+    }
+
+    return TRUE;
+
+#if defined(_DEBUG) && 0
+//   fprintf( stderr, "this: %p m_pUser: %p ", this, m_pUser );
+    switch( pEvent->event )
+    {
+       case HX_MOUSE_LEAVE:
+           fprintf( stderr, "HX_MOUSE_LEAVE\n" );
+           break;
+//        case HX_MOUSE_MOVE:
+//           point.x = ((HXxPoint*)pEvent->param1)->x;
+//           point.y = ((HXxPoint*)pEvent->param1)->y;
+//           fprintf( stderr, "HX_MOUSE_MOVE: %d %d\n", point.x, point.y );
+//           break;
+       case HX_MOUSE_ENTER:
+           fprintf( stderr, "HX_MOUSE_ENTER\n" );
+           break;
+//        case MotionNotify:
+//           point.x = ((XMotionEvent*)pEvent->param2)->x;
+//           point.y = ((XMotionEvent*)pEvent->param2)->y;
+//           fprintf( stderr, "MotionNotify: %d %d\n", point.x, point.y );
+//           break;
+       case Expose:
+           fprintf( stderr, "Expose\n" );
+           break;
+       case EnterNotify :
+           fprintf( stderr, "EnterNotify\n" );
+           break;
+       case LeaveNotify:
+           fprintf( stderr, "LeaveNotify\n" );
+           break;
+       case KeyPress:
+           fprintf( stderr, "this: %p m_pUser: %p ", this, m_pUser );
+           fprintf( stderr, "Keypress\n\n" );
+           break;
+       case KeyRelease:
+           fprintf( stderr, "this: %p m_pUser: %p ", this, m_pUser );
+           fprintf( stderr, "KeyRelease\n" );
+           break;
+       default:
+           fprintf( stderr, "Other\n" );
+           break;
+    }
+#endif
+
+    //Find the ConfigureNotify events so we can drop to RGB from
+    //overlay while we move....
+//     if( pEvent->event == ConfigureNotify && this==m_pTopLevelSite )
+//     {
+//        XConfigureEvent* pev = (XConfigureEvent*)pEvent->param2;
+//        if( m_pWindow && pev->window == (Window)m_pWindow->window )
+//        {
+//           HXxPoint p;
+//           _GetPositionRelativeToActualWindow( p );
+//  //           fprintf( stderr, "wint %p  -- x,y width, height: %d %d %d %d \n",
+//  //                    pev->window,
+//  //                    pev->x, pev->y, pev->width, pev->height);
+//  //           fprintf( stderr, "size of site: %d %d\n", m_size.cx, m_size.cy);
+//  //           fprintf( stderr, "pos of site: %d %d\n", m_topleft.x, m_topleft.y);
+//           m_pTopLevelSite->m_pMutex->Lock();
+//           m_pTopLevelSite->SiteMoving(0, 0);
+//           m_pTopLevelSite->m_nLastMoveTime = HX_GET_TICKCOUNT();
+//           m_pTopLevelSite->ScheduleCallback(MOUSE, 100);
+//           m_pTopLevelSite->m_pMutex->Unlock();
+//        }
+//     }
+
+    //See if we should drop out of full screen
+    if( pEvent->event == FocusOut && IsFullScreen() && !m_bIgnoreFocusOutInFS )
+    {
+//         fprintf( stderr, "_HandleOSEvents: focus out: " );
+//         XEvent* pXEvent = (XEvent*) pEvent->param2;
+//         XFocusChangeEvent* event = (XFocusChangeEvent*) pXEvent;
+//         switch( event->mode )
+//         {
+//            case NotifyAncestor:
+//                fprintf( stderr, "NotifyAncestor\n" );
+//                break;
+//            case NotifyVirtual:
+//                fprintf( stderr, "NotifyVirtual\n" );
+//                break;
+//            case NotifyInferior:
+//                fprintf( stderr, "NotifyInferior\n" );
+//                break;
+//            case NotifyNonlinear:
+//                fprintf( stderr, "NotifyNonlinear\n" );
+//                break;
+//            case NotifyNonlinearVirtual:
+//                fprintf( stderr, "NotifyNonlinearVirtual\n" );
+//                break;
+//            case NotifyPointer:
+//                fprintf( stderr, "NotifyPointer\n" );
+//                break;
+//            case NotifyPointerRoot:
+//                fprintf( stderr, "NotifyPointerRoot\n" );
+//                break;
+//            case NotifyDetailNone:
+//                fprintf( stderr, "NotifyDetailNone\n" );
+//                break;
+//            default:
+//                fprintf( stderr, "screwed.....\n" );
+//         }
+        ExitFullScreen();
+    }
+
+
+#if defined(_DEBUG) && defined(TEST_FULL_SCREEN)
+    if( pEvent->event == KeyPress )
+    {
+        KeySym sym;
+        char   szBuf[10]; /* Flawfinder: ignore */
+        int    nNum;
+
+        //Lookup the key without any state.
+        nNum = XLookupString( (XKeyEvent*)(pEvent->param2), szBuf, 10, &sym, NULL );
+        if( nNum > 0 )
+        {
+            if( 'f' == szBuf[0] && IsFullScreen() )
+            {
+                //Exit full screen if 'f' is pressed.....
+                m_pTopLevelSite->ExitFullScreen();
+            }
+            else if( 'f' == szBuf[0] && !IsFullScreen() )
+            {
+                //Enter full screen if 'f' is pressed.....
+                m_pTopLevelSite->EnterFullScreen();
+            }
+
+        }
+
+    }
+#endif
+
+#if defined(_DEBUG) && defined(_TEST_COLOR_CONTROLS)
+    if( pEvent->event == KeyPress )
+    {
+        KeySym sym;
+        char   szBuf[10]; /* Flawfinder: ignore */
+        int    nNum;
+
+        //Lookup the key without any state.
+        nNum = XLookupString( (XKeyEvent*)(pEvent->param2), szBuf, 10, &sym, NULL );
+        if( nNum > 0 )
+        {
+            if( 'b' == szBuf[0] )
+            {
+                SetBrightness( GetBrightness()-.05);
+            }
+            if( 'B' == szBuf[0] )
+            {
+                SetBrightness( GetBrightness()+.05);
+            }
+
+            if( 'c' == szBuf[0] )
+            {
+                SetContrast( GetContrast()-.05);
+            }
+            if( 'C' == szBuf[0] )
+            {
+                SetContrast( GetContrast()+.05);
+            }
+
+            if( 'h' == szBuf[0] )
+            {
+                SetHue( GetHue()-.05);
+            }
+            if( 'H' == szBuf[0] )
+            {
+                SetHue( GetHue()+.05 );
+            }
+
+            if( 's' == szBuf[0] )
+            {
+                SetSaturation( GetSaturation()-.05);
+            }
+            if( 'S' == szBuf[0] )
+            {
+                SetSaturation( GetSaturation()+.05);
+            }
+            fprintf( stderr, "colors %f %f %f %f\n",
+                     GetBrightness(),
+                     GetContrast(),
+                     GetSaturation(),
+                     GetHue());
+        }
+
+    }
+#endif
+
+    //Exit full screen on ESC pressed......
+    if( pEvent->event == KeyPress )
+    {
+        KeySym sym;
+        char   szBuf[10]; /* Flawfinder: ignore */
+        int    nNum;
+
+        //Lookup the key without any state.
+        nNum = XLookupString( (XKeyEvent*)(pEvent->param2), szBuf, 10, &sym, NULL );
+        if( nNum > 0 )
+        {
+            if( 27 == (int)szBuf[0] && IsFullScreen() )
+            {
+                //Exit full screen if esc is pressed.....
+                m_pTopLevelSite->ExitFullScreen();
+            }
+        }
+    }
+
+    //Find out if this is an event we are interested in.  Make sure we
+    //are visible, it isn't a button, expose or FocusIn event and also
+    //make sure it is headed for our window.
+    if (!_ShouldProcess(pEvent))
+    {
+        return FALSE;
+    }
+
+
+    if(m_pUser && GetWindow() && GetWindow()->window)
+    {
+        //Do not send an update event to a hidden site.
+        if( pEvent->event == Expose ||
+            pEvent->event == FocusIn  ||
+            pEvent->event == HX_SURFACE_UPDATE )
+        {
+            if( (m_ScrollVertButtonT || m_ScrollHorizButtonR) && IsSiteVisible() )
+            {
+                _DrawArrows();
+            }
+            _ForwardUpdateEvent(pEvent);
+            return TRUE;
+        }
+        else
+        {
+            // get original events info from pEvent
+            XEvent* pXEvent = (XEvent*) pEvent->param2;
+            XButtonEvent* buttonEvent = (XButtonEvent*) pXEvent;
+
+
+            //XXXgfw all this code sucks! It really need to be written
+            //for just native events or RMA events. With the change to a
+            //common site it is all screwed up. I am leaving it for now
+            //so we can get on with transparancy but get back to it!
+
+            //If the user clicks MB1 on a scroll button, handle it here and
+            //don't pass it up or let the user handle the event.
+            //Hit detection here.
+
+            ////////////////////////////////////////////////////////
+            // BEGIN SCROLLING GARBAGE
+            ////////////////////////////////////////////////////////
+            if(
+                ((pEvent->event==ButtonPress || pEvent->event==ButtonRelease) &&
+                 buttonEvent->button==Button1) &&
+                (m_ScrollHorizButtonL || m_ScrollVertButtonB )
+                )
+            {
+                int buttonX=0;
+                int buttonY=0;
+
+                if( pEvent->event==ButtonRelease )
+                {
+                    if( m_bScrollingInProgress )
+                    {
+                        m_bScrollingInProgress = FALSE;
+                        m_nScrollDir = 0;
+                        return TRUE ;
+                    }
+                }
+                else
+                {
+                    buttonX = buttonEvent->x;
+                    buttonY = buttonEvent->y;
+
+                    HXBOOL bPointInSite = FALSE;
+                    if( m_Region )
+                        bPointInSite = HXPointInRegion(m_Region, buttonX, buttonY);
+
+                    if( bPointInSite )
+                    {
+                        if( m_ScrollHorizButtonL )
+                        {
+                            if( _InButton( m_ptScrollHorizPosL, buttonX, buttonY ))
+                            {
+                                m_bScrollingInProgress = TRUE;
+                                m_nScrollDir = 1;
+                            }
+                            if( _InButton( m_ptScrollHorizPosR, buttonX, buttonY ))
+                            {
+                                m_bScrollingInProgress = TRUE;
+                                m_nScrollDir = 2;
+                            }
+                        }
+                        if( m_ScrollVertButtonT )
+                        {
+                            if( _InButton( m_ptScrollVertPosT, buttonX, buttonY ))
+                            {
+                                m_bScrollingInProgress = TRUE;
+                                m_nScrollDir = 3;
+                            }
+                            if( _InButton( m_ptScrollVertPosB, buttonX, buttonY ))
+                            {
+                                m_bScrollingInProgress = TRUE;
+                                m_nScrollDir = 4;
+                            }
+                        }
+                    }
+                }
+
+                if( (m_ScrollHorizButtonL||m_ScrollVertButtonT) && m_bScrollingInProgress)
+                {
+                    int xx=0;
+                    int yy=0;
+                    HXxWindow* pParentWindow = GetParentSite()->GetWindow();
+                    //Make it scroll 10% of the parent window each click.
+                    HXxSize sizeTmp;
+                    GetParentSite()->GetSize(sizeTmp);
+
+                    //Set it to a percentage of the slider range.
+                    int incX = sizeTmp.cx/10;
+                    int incY = sizeTmp.cy/10;
+
+                    HX_ASSERT( pParentWindow );
+
+                    xx = m_XSliderPos;
+                    yy = m_YSliderPos;
+
+                    if( m_nScrollDir == 1 )
+                        xx-=incX;
+                    if( m_nScrollDir == 2 )
+                        xx+=incX;
+                    if( m_nScrollDir == 3 )
+                        yy-=incY;
+                    if( m_nScrollDir == 4 )
+                        yy+=incY;
+
+                    if( xx > m_size.cx-sizeTmp.cx )
+                        xx = m_size.cx-sizeTmp.cx;
+                    if( yy > m_size.cy-sizeTmp.cy)
+                        yy = m_size.cy-sizeTmp.cy;
+
+                    if( xx < 0 )
+                        xx = 0;
+                    if( yy < 0 )
+                        yy = 0;
+
+                    m_XSliderPos = xx;
+                    m_YSliderPos = yy;
+
+                    HXxRect rect;
+                    DamageRect(rect);
+
+                    InternalForceRedraw();
+                }
+                //Only throw away the event if it had something to do with
+                //scolling.
+                if( m_bScrollingInProgress )
+                {
+                    m_bScrollingInProgress = FALSE;
+                    m_nScrollDir = 0;
+                    return TRUE;
+                }
+            }
+            ////////////////////////////////////////////////////////
+            // END SCROLLING GARBAGE
+            ////////////////////////////////////////////////////////
+            point.x = -1;
+            point.y = -1;
+
+            if( pEvent->event == MotionNotify)
+            {
+                point.x = ((XMotionEvent*)pXEvent)->x;
+                point.y = ((XMotionEvent*)pXEvent)->y;
+            }
+            else if( pEvent->event == ButtonPress )
+            {
+                point.x = ((XMotionEvent*)pXEvent)->x;
+                point.y = ((XMotionEvent*)pXEvent)->y;
+            }
+
+            //
+            //Give the user a chance at the native event.
+            //
+            if( m_RegionWithoutChildren && HXPointInRegion(m_RegionWithoutChildren, point.x, point.y ))
+            {
+                if( m_Region && HXPointInRegion(m_Region, point.x, point.y) )
+                {
+                    if (m_pUser)
+                        m_pUser->HandleEvent(pEvent);
+                }
+                else
+                {
+                    INT32 handledCount = 0;
+                    INT32 mapCount     = 0;
+
+                    //try send this to all of our children
+                  _unixsitecpp1:
+                    mapCount = m_ChildrenMap.GetCount();
+                    CHXMapPtrToPtr::Iterator i;
+                    for(i=m_ChildrenMap.Begin() ; i!=m_ChildrenMap.End() ; ++i)
+                    {
+                        CHXBaseSite* pSite = (CHXBaseSite*) *i;
+                        pSite->_HandleOSEvents(pEvent);
+                        if (pEvent->handled)
+                        {
+                            break;
+                        }
+                        handledCount+=pEvent->handled;
+                        pEvent->handled=0;
+
+                        if (m_ChildrenMap.GetCount() != mapCount)
+                        {
+                            goto _unixsitecpp1;
+                        }
+                    }
+                    if (handledCount)
+                    {
+                        pEvent->handled = 1;
+                    }
+                    HX_ASSERT(handledCount<2);
+                }
+            }
+            pEvent->handled=FALSE;
+        }
+    }
+
+    return FALSE;
+}
+
+void CHXExSite::_GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2)
+{
+    //XXXgfw Not needed on UNIX I guess???
+}
+
+void CHXExSite::_GenerateSetCursorEvent()
+{
+#ifdef _DEBUG
+    fprintf( stderr, "CHXExSite::_GenerateSetCursorEvent\n" );
+#endif
+    //XXXgfw do we need this??
+}
+
+void CHXExSite::_TryCreateXSlider()
+{
+#if 0
+    if( !m_ScrollHorizButtonL && IsSiteVisible() )
+        _CreateHorizScrollBar();
+#endif
+}
+
+void CHXExSite::_SetXSliderValues(INT32 range, INT32 pageSize)
+{
+    //XXXgfw this is a do nothing as long as we only have
+    //scroll buttons on unix and not real scroll bars.
+}
+
+void CHXExSite::_TryCreateYSlider()
+{
+#if 0
+    if( !m_ScrollVertButtonT && IsSiteVisible() )
+        _CreateVertScrollBar();
+#endif
+}
+
+void CHXExSite::_SetYSliderValues(INT32 range, INT32 pageSize)
+{
+    //XXXgfw this is a do nothing as long as we only have
+    //scroll buttons on unix and not real scroll bars.
+}
+
+void CHXExSite::_GetSystemSizeOfSliders(INT32* pWidth, INT32* pHeight)
+{
+#if 0
+    *pWidth = *pHeight = SCROLL_BAR_WIDTH;
+#endif
+}
+
+HXBOOL CHXExSite::_IsWindowVisible()
+{
+#if 0
+    HX_RESULT retVal = FALSE;
+    //XXXgfw do this for now...
+    retVal = IsSiteVisible();
+    return retVal;
+#else
+    return FALSE;
+#endif
+
+}
+
+void CHXExSite::_ShowXSlider(HXBOOL bShow)
+{
+#if 0
+    if( GetWindow() )
+    {
+        if( bShow )
+            _MapHorzScroll();
+        else
+            _UnmapHorzScroll();
+    }
+#endif
+}
+
+void CHXExSite::_MoveXSlider( INT32 left,
+                                INT32 top,
+                                INT32 right,
+                                INT32 bottom,
+                                HXBOOL bRedraw )
+{
+    //Do nothing right now....
+}
+
+void CHXExSite::_ShowYSlider(HXBOOL bShow)
+{
+#if 0
+    if( GetWindow() )
+    {
+        if( bShow )
+            _MapVertScroll();
+        else
+            _UnmapVertScroll();
+    }
+#endif
+}
+
+void CHXExSite::_MoveYSlider( INT32 left,
+                                INT32 top,
+                                INT32 right,
+                                INT32 bottom,
+                                HXBOOL bRedraw)
+{
+    //do nothing right now...
+}
+
+HXBOOL CHXExSite::_DoesXSliderExist()
+{
+    return FALSE;
+//    return (m_ScrollHorizButtonL!=0);
+}
+
+void* CHXExSite::_GetContainingWindow()
+{
+    //XXXgfw Do we need this???
+    return NULL;
+}
+
+void CHXExSite::_GetCursorPos(HXxPoint* pPoint)
+{
+    //Return the cursor pos in screen coords.
+    Window rootWin;
+    Window childWin;
+    int rootX=0;
+    int rootY=0;
+    int childX=0;
+    int childY=0;
+    unsigned int mask=0;
+    Bool ret=FALSE;
+
+    HX_ASSERT(GetWindow());
+    Display* pDis = (Display*)GetWindow()->display;
+    XLockDisplay(pDis);
+    ret = XQueryPointer(pDis,
+                        (Window)GetWindow()->window,
+                        &rootWin,
+                        &childWin,
+                        &rootX, &rootY,
+                        &childX, &childY,
+                        &mask);
+    XUnlockDisplay(pDis);
+
+    if(ret)
+    {
+        pPoint->x = rootX;
+        pPoint->y = rootY;
+    }
+}
+void* CHXExSite::_GetWindowWithCursor()
+{
+#if 0
+    //Return the cursor pos in screen coords.
+    void*        pRet  = NULL;
+    int          rootX = 0;
+    int          rootY = 0;
+    int          childX= 0;
+    int          childY= 0;
+    unsigned int mask  = 0;
+    Bool         ret   = FALSE;
+    Window       rootWin;
+    Window       childWin;
+
+    HX_ASSERT(GetWindow());
+    Display* pDis = (Display*)GetWindow()->display;
+    XLockDisplay(pDis);
+    ret = XQueryPointer(pDis,
+                        (Window)GetWindow()->window,
+                        &rootWin,
+                        &childWin,
+                        &rootX, &rootY,
+                        &childX, &childY,
+                        &mask);
+    XUnlockDisplay(pDis);
+
+    if(ret)
+    {
+        pRet = (void*)childWin;
+    }
+    return pRet;
+#else
+     HX_ASSERT( "Not implemented..." == NULL );
+     return NULL;
+#endif
+}
+
+void CHXExSite::_MapPointToOSWindow(HXxPoint* pPt, void** pWindowHandle)
+{
+    //XXXgfw we could query the window tree and traverse down but that
+    //is really slow and this isn't used right now.
+    HX_ASSERT( "Not implemented..." == NULL );
+}
+
+void CHXExSite::_ReInitPrimarySurface()
+{
+    //Nothing to do in unix here right?
+}
+
+HXBOOL CHXExSite::_MoveWindow( void* win,
+                               INT32 X,
+                               INT32 Y,
+                               INT32 nWidth,
+                               INT32 nHeight,
+                               HXBOOL bRepaint)
+{
+#if 0
+    //XXXgfw we still have to do bRepaint....
+    HX_ASSERT( m_pWindow && m_pWindow->window && m_pWindow->display);
+    _DestroyScrollButtons();
+    XLockDisplay((Display*) m_pWindow->display);
+    XMoveResizeWindow( (Display*)m_pWindow->display,
+                       (Window)m_pWindow->window,
+                       X,
+                       Y,
+                       nWidth,
+                       nHeight
+                       );
+    XUnlockDisplay((Display*) m_pWindow->display);
+#else
+    HX_ASSERT( "Not implemented..." == NULL );
+#endif
+    return TRUE;
+}
+
+HXBOOL CHXExSite::_UpdateWindow(void* hWnd)
+{
+    //We need to generate a repaint here of the window....
+    return TRUE;
+}
+
+HXBOOL CHXExSite::_ShowWindow(void* hWnd, INT32 nCmdShow)
+{
+#if 0
+    HX_ASSERT( nCmdShow==HX_SHOW_WINDOW || nCmdShow==HX_HIDE_WINDOW);
+    if( !m_pWindow || !m_pWindow->window || !m_pWindow->display )
+        return FALSE;
+
+    if( nCmdShow == HX_SHOW_WINDOW )
+    {
+        _MapScrollButtons();
+        XLockDisplay((Display*) m_pWindow->display);
+        XMapWindow( (Display*)m_pWindow->display, (Window)m_pWindow->window );
+        XUnlockDisplay((Display*) m_pWindow->display);
+    }
+    else
+    {
+        _UnmapScrollButtons();
+        XLockDisplay((Display*) m_pWindow->display);
+        XUnmapWindow( (Display*)m_pWindow->display, (Window)m_pWindow->window );
+        XUnlockDisplay((Display*) m_pWindow->display);
+    }
+#endif
+    return TRUE;
+}
+
+HXBOOL CHXExSite::_SetWindowPos(void* hWnd,
+                                void* hWndInsertAfter,
+                                INT32 X,
+                                INT32 Y,
+                                INT32 cx,
+                                INT32 cy,
+                                INT32 uFlags)
+{
+#ifdef _DEBUG
+    fprintf( stderr, "Now what on earth is this suppose to do??\n" );
+#endif
+    return TRUE;
+}
+
+HXBOOL CHXExSite::_SetWindowRgn(void* hWnd, HXREGION* hRgn, HXBOOL bRedraw)
+{
+#if 0
+    HX_ASSERT( GetWindow() );
+    Display* pDis = (Display*)GetWindow()->display;
+    XLockDisplay(pDis);
+    XSetRegion( pDis,
+                (GC)m_pVideoSurface->_GetDC(NULL),
+                (Region)hRgn
+                );
+    XUnlockDisplay(pDis);
+    if( bRedraw )
+    {
+        HX_ASSERT("Redraw asked for here"==NULL );
+    }
+#endif
+    return TRUE;
+}
+
+void CHXExSite::_SetFocus(void* pWindow)
+{
+#if 0
+    XWindowAttributes attr;
+    HXxWindow*        pWin = GetWindow();
+
+    HX_ASSERT(pWin);
+    HX_ASSERT(pWindow);
+
+    XLockDisplay((Display*) pWin->display);
+    XGetWindowAttributes((Display*)pWin->display, (Window)pWindow, &attr);
+    XUnlockDisplay((Display*) pWin->display);
+    if( attr.map_state == IsViewable )
+    {
+        XLockDisplay((Display*) pWin->display);
+        XSetInputFocus( (Display*)pWin->display,
+                        (Window)pWindow,
+                        RevertToParent,
+                        CurrentTime
+                        );
+        XUnlockDisplay((Display*) pWin->display);
+    }
+
+    return;
+#endif
+}
+
+HX_RESULT CHXExSite::_EnterFullScreen(HXxWindow* pWindow)
+{
+#if 0
+    HXxWindow* pWin = GetWindow();
+    HX_ASSERT( pWin && pWin->display && pWin->display);
+    HX_ASSERT( this == m_pTopLevelSite );
+
+    if( 0 != m_winFullScreenWindow || IsFullScreen() )
+    {
+        //We are already in full screen
+        return HXR_FAIL;
+    }
+
+    //Create a override redirect window to fill the root.
+    XSizeHints           size_hints;
+    XLockDisplay((Display*) pWin->display);
+    Screen*              pScreen = XDefaultScreenOfDisplay((Display*)pWin->display);
+    XUnlockDisplay((Display*) pWin->display);
+    UINT16               uHorzRes = WidthOfScreen(pScreen);
+    UINT16               uVertRes = HeightOfScreen(pScreen);
+    int                  attrMask = 0;
+    XSetWindowAttributes attr;
+
+    memset(&attr, 0, sizeof(XSetWindowAttributes));
+    attrMask = CWOverrideRedirect | CWBorderPixel |
+        CWBackPixel | CWCursor;
+    attr.cursor = None;
+    attr.override_redirect = True;
+    XLockDisplay((Display*)pWin->display);
+    attr.background_pixel = BlackPixel((Display*)pWin->display,
+                                       DefaultScreen((Display*)pWin->display));
+    attr.border_pixel     = BlackPixel((Display*)pWin->display,
+                                       DefaultScreen((Display*)pWin->display));
+    XUnlockDisplay((Display*)pWin->display);
+
+    size_hints.flags  = PPosition | PSize;
+    size_hints.x      = 0;
+    size_hints.y      = 0;
+    size_hints.width  = uHorzRes;
+    size_hints.height = uVertRes;
+
+    //Create it.
+    XLockDisplay((Display*) pWin->display);
+    Window window = XCreateWindow((Display*)pWin->display,
+                                  DefaultRootWindow((Display*)pWin->display),
+                                  size_hints.x,
+                                  size_hints.y,
+                                  size_hints.width,
+                                  size_hints.height,
+                                  0,
+                                  CopyFromParent,
+                                  InputOutput,
+                                  CopyFromParent,
+                                  attrMask,
+                                  &attr);
+
+    //Tell the WM about this window.
+    XSetStandardProperties( (Display*)pWin->display,
+                            window,
+                            "unixfullscreen",
+                            "unixfullscreen",
+                            None,
+                            NULL, 0,
+                            &size_hints
+                            );
+
+    int result = XSelectInput( zm_display, window,
+                               ButtonPressMask   | ButtonReleaseMask | KeyPressMask    |
+                               KeyReleaseMask    | EnterWindowMask   | LeaveWindowMask |
+                               PointerMotionMask | ButtonMotionMask  | KeymapStateMask |
+                               ExposureMask      | StructureNotifyMask | FocusChangeMask
+                               );
+
+    //Map the window.
+    XMapWindow((Display*)pWin->display, window);
+    XUnlockDisplay((Display*) pWin->display);
+
+
+    //Get ready to resize the presentation....
+    if(m_pTopLevelSite)
+    {
+        m_pTopLevelSite->m_bDisableForceRedraw = TRUE;
+    }
+
+    //Maintain aspect ratio and Scale it.
+    float fXScale   = (float)uHorzRes/(float)(m_size.cx);
+    float fYScale   = (float)uVertRes/(float)(m_size.cy);
+    float fScale    = (fXScale<fYScale) ? fXScale : fYScale;
+    int nWidth      = (int)(fScale*m_size.cx+.5);
+    int nHeight     = (int)(fScale*m_size.cy+.5);
+
+    //Center the presentation and save the old size
+    memcpy( &m_PreFullScreenSize, &m_size, sizeof( HXxSize) ); /* Flawfinder: ignore */
+    HXxSize size = {nWidth, nHeight};
+
+    if( nWidth<uHorzRes )
+        m_ptFullScreenOffset.x = (uHorzRes-nWidth)/2;
+
+    if( nHeight<uVertRes )
+        m_ptFullScreenOffset.y = (uVertRes-nHeight)/2;
+
+    //Reparent our main window.......
+    Window       winRootParent = 0;
+    Window       winParent     = 0;
+    Window*      pwinChildren  = NULL;
+    unsigned int nNumChildren  = 0;
+    XLockDisplay((Display*) pWin->display);
+    XQueryTree( (Display*)pWin->display,
+                (Window)pWin->window,
+                &winRootParent,
+                &winParent,
+                &pwinChildren,
+                &nNumChildren
+                );
+    //Free unused children list.
+    XFree( pwinChildren );
+    XUnlockDisplay((Display*) pWin->display);
+
+    HX_ASSERT( winParent );
+    m_winOldParent = winParent;
+    XLockDisplay((Display*) pWin->display);
+    XReparentWindow( (Display*)pWin->display,
+                     (Window)pWin->window,
+                     window,
+                     m_ptFullScreenOffset.x,
+                     m_ptFullScreenOffset.y
+                     );
+
+    //Flush event queue.
+    XSync((Display*)pWin->display, False);
+    XUnlockDisplay((Display*) pWin->display);
+
+    //Save it
+    m_winFullScreenWindow = window;
+    m_bInFullScreen = TRUE;
+
+    //Now resize it...
+    SetSize(m_size);
+    //Redraw the presentation....
+    m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
+    _ForceRedrawAll();
+
+    //Give it focus....
+    _SetFocus( (void*)pWin->window );
+
+    // now eat all the focusouts that came as a result of this reparent...
+    XEvent event;
+    XLockDisplay((Display*) pWin->display);
+    HXBOOL status   =  XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window,
+                                            FocusOut, &event);
+    XUnlockDisplay((Display*) pWin->display);
+    while (m_bWindowCreatedByCreate && status)
+    {
+        // just discarding these
+        XLockDisplay((Display*) pWin->display);
+        status   =  XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window,
+                                           FocusOut, &event);
+        XUnlockDisplay((Display*) pWin->display);
+    }
+
+    //Update the status text...
+    if(m_pStatusText)
+    {
+        m_pStatusText->ParentChangedSize();
+        m_pStatusText->Show();
+    }
+
+#else
+    HX_ASSERT( "Not implemented..." == NULL );
+#endif
+    return HXR_OK;
+}
+
+HX_RESULT CHXExSite::_ExitFullScreen()
+{
+#if 0
+    HX_ASSERT( this == m_pTopLevelSite );
+
+    HXxWindow* pWin = GetWindow();
+
+    HX_ASSERT( pWin && pWin->display && pWin->window );
+
+    //Give the window back to the TLC.
+
+    XLockDisplay((Display*) pWin->display);
+    XReparentWindow( (Display*)pWin->display,
+                     (Window)pWin->window,
+                     m_winOldParent,
+                     m_position.x, m_position.y
+                     );
+    XUnlockDisplay((Display*) pWin->display);
+
+    //Just kill our window and take us out of full screen....
+    if( 0 != m_winFullScreenWindow )
+    {
+        XLockDisplay((Display*) pWin->display);
+        XDestroyWindow( (Display*)pWin->display, m_winFullScreenWindow );
+        XUnlockDisplay((Display*) pWin->display);
+        m_winFullScreenWindow = 0;
+    }
+
+    m_bDisableForceRedraw = TRUE;
+
+    m_bInFullScreen = FALSE;
+    HXxSize size = {0,0};
+    memcpy( &size, &m_PreFullScreenSize, sizeof(HXxSize) ); /* Flawfinder: ignore */
+    m_PreFullScreenSize.cx = m_PreFullScreenSize.cy = 0;
+
+    SetSize(size);
+    _SetFocus( (void*)pWin->window );
+    m_ptFullScreenOffset.x = 0;
+    m_ptFullScreenOffset.y = 0;
+
+
+    m_bDisableForceRedraw = FALSE;
+    _ForceRedrawAll();
+
+    if(m_pStatusText)
+    {
+        m_pStatusText->ParentChangedSize();
+        m_pStatusText->Hide();
+    }
+
+    //move the site back to where it was.
+    if( m_pTopLevelSite )
+    {
+        m_pTopLevelSite->_SetPosition(m_CreateWindowPos);
+    }
+
+    return HXR_OK;
+#else
+    HX_ASSERT( "Not implemented..." == NULL );
+#endif
+}
+
+HX_RESULT CHXExSite::_EnterFullScreenNoNewWindow()
+{
+#if 0
+    HXxWindow* pWin = GetWindow();
+
+    HX_ASSERT( pWin && pWin->display && pWin->display);
+    HX_ASSERT( this == m_pTopLevelSite );
+
+    if(IsFullScreen() || !pWin)
+    {
+        //We are already in full screen
+        return HXR_FAIL;
+    }
+
+    //Get the screen size.
+    XLockDisplay((Display*) pWin->display);
+    Screen*              pScreen = XDefaultScreenOfDisplay((Display*)pWin->display);
+    UINT16               uHorzRes = WidthOfScreen(pScreen);
+    UINT16               uVertRes = HeightOfScreen(pScreen);
+    XUnlockDisplay((Display*)pWin->display);
+
+    //Get ready to resize the presentation....
+    if( m_pTopLevelSite )
+    {
+        m_pTopLevelSite->m_bDisableForceRedraw = TRUE;
+    }
+
+    //Maintain aspect ratio and Scale it.
+    float fXScale   = (float)uHorzRes/(float)(m_size.cx);
+    float fYScale   = (float)uVertRes/(float)(m_size.cy);
+    float fScale    = (fXScale<fYScale) ? fXScale : fYScale;
+    int nWidth      = (int)(fScale*m_size.cx+.5);
+    int nHeight     = (int)(fScale*m_size.cy+.5);
+
+    //Center the presentation and save the old size
+    memcpy( &m_PreFullScreenSize, &m_size, sizeof( HXxSize) ); /* Flawfinder: ignore */
+    
+    HXxSize size = {nWidth, nHeight};
+
+    if( nWidth < uHorzRes )
+    {
+        m_ptFullScreenOffset.x = (uHorzRes - nWidth)/2;
+    }
+    
+    if( nHeight < uVertRes )
+    {
+        m_ptFullScreenOffset.y = (uVertRes - nHeight)/2;
+    }
+
+    //Reparent our main window.......
+    Window       winRootParent = 0;
+    Window       winParent     = 0;
+    Window*      pwinChildren  = NULL;
+    unsigned int nNumChildren  = 0;
+    XLockDisplay((Display*) pWin->display);
+    XQueryTree( (Display*)pWin->display,
+				(Window)pWin->window,
+				&winRootParent,
+				&winParent,
+				&pwinChildren,
+				&nNumChildren
+				);
+
+    //Free unused children list.
+    XFree( pwinChildren );
+    XUnlockDisplay((Display*) pWin->display);
+    
+    HX_ASSERT( winParent );
+    m_winOldParent = winParent;
+
+    m_bInFullScreen = TRUE;
+
+    //Now resize it...
+    SetSize(m_size);
+
+    //Redraw the presentation....
+    if( m_pTopLevelSite )
+    {
+        m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
+    }
+
+    _ForceRedrawAll();
+
+    //Give it focus....
+    _SetFocus( (void*)pWin->window );
+
+    // now eat all the focusouts that came as a result of this reparent...
+    XEvent event;
+    XLockDisplay((Display*) pWin->display);
+    HXBOOL status   =  XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window,
+        											FocusOut, &event);
+    XUnlockDisplay((Display*) pWin->display);
+    while (m_bWindowCreatedByCreate && status)
+    {
+        // just discarding these
+        XLockDisplay((Display*) pWin->display);
+        status   =  XCheckTypedWindowEvent((Display*)pWin->display, (Window)pWin->window,
+										   FocusOut, &event);
+        XUnlockDisplay((Display*) pWin->display);
+    }
+    
+	//Update the status text...
+    if(m_pStatusText)
+    {
+        m_pStatusText->ParentChangedSize();
+        m_pStatusText->Show();
+    }
+#if defined(HELIX_CONFIG_MOBLIN)
+    if(!m_pAttachWindowCallback)
+    {
+        m_pAttachWindowCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)AttachWindowCallback);
+        m_pAttachWindowCallback->AddRef();
+    }
+    if(!m_pForceRedrawCallback)
+    {
+        m_pForceRedrawCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)ForceRedrawCallback);
+        m_pForceRedrawCallback->AddRef();
+    }
+
+    // schedule callback for Attaching Window
+    if(m_pAttachWindowCallback)
+    {
+    	m_pAttachWindowCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pAttachWindowCallback, 100));
+    }
+    if(m_pForceRedrawCallback)
+    {
+    	m_pForceRedrawCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pForceRedrawCallback, 500));
+    }
+	
+#endif
+#else
+    HX_ASSERT( "Not implemented..." == NULL );
+#endif
+    return HXR_OK;
+}
+
+#if defined(HELIX_CONFIG_MOBLIN)    
+void CHXExSite::AttachWindowCallback(void* pParam)
+{
+    CHXExSite* pObj = (CHXExSite*)pParam;
+    if (pObj)
+    {
+        pObj->_AttachWindow();
+    }
+}
+
+
+void CHXExSite::ForceRedrawCallback(void* pParam)
+{
+    CHXExSite* pObj = (CHXExSite*)pParam;
+
+    if (pObj)
+    {
+        UINT32 ulNumOfChildren = pObj->GetNumberOfChildSites();
+        if(pObj->m_pTopLevelSite)
+        {
+            pObj->m_pTopLevelSite->m_bDisableForceRedraw = FALSE;
+        }
+        for ( UINT32 i = 0; i < ulNumOfChildren; ++i )
+        {
+            SPIHXSite spChildSite;
+            if ( SUCCEEDED( pObj->GetNthChildSite( i, *spChildSite.AsInOutParam() ) ) 
+			&& spChildSite.IsValid() )
+            {
+                spChildSite->DamageRegion( NULL );
+                spChildSite->ForceRedraw();
+            }
+            
+        }
+    }
+}
+
+void CHXExSite::RemovePendingCallback(CHXGenericCallback* pCB)
+{
+    if (pCB && 
+        pCB->GetPendingCallback() &&
+        m_pScheduler)
+    {
+        m_pScheduler->Remove(pCB->GetPendingCallback());
+        pCB->CallbackCanceled();
+    }
+}
+#endif
+
+HX_RESULT CHXExSite::_EnterFullScreenExt(HXxWindow* pWindow, IHXValues* pValues)
+{
+#if 0
+    m_bReparent = FALSE;
+    HX_RESULT res = HXR_OK;
+    UINT32 ulReparent = 0;
+
+    if (pValues)
+    {
+        pValues->GetPropertyULONG32("Reparent", ulReparent);
+    }
+
+    m_bReparent = (HXBOOL)ulReparent;
+
+    if (m_bReparent)
+    {
+        res = _EnterFullScreen(pWindow);
+    }
+    else
+    {
+        res = _EnterFullScreenNoNewWindow();
+    }
+    
+    CHXBaseSite::FullScreenEntered(res);
+    return res;
+#else
+    HX_ASSERT( "Not implemented..." == NULL );
+    return HXR_OK;  /* this makes compiler happy */
+#endif
+}
+
+HX_RESULT CHXExSite::_ExitFullScreenExt()
+{
+#if 0
+    HX_RESULT res = _ExitFullScreen();
+#if defined(HELIX_CONFIG_MOBLIN)	
+    // schedule callback for attaching window
+    if(m_pAttachWindowCallback)
+    {
+        m_pAttachWindowCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pAttachWindowCallback, 100));
+    }
+    // schedule callback for Force Redraw the window
+    if(m_pForceRedrawCallback)
+    {
+        m_pForceRedrawCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pForceRedrawCallback, 500));
+    }
+#endif	
+    CHXBaseSite::FullScreenExited(res);
+
+    return res;
+#else
+    HX_ASSERT( "Not implemented..." == NULL );
+    return HXR_OK;  /* this makes compiler happy */
+#endif
+
+}
+
+HX_RESULT CHXExSite::_EventOccurred(HXxEvent* pEvent)
+{
+    return HXR_OK;
+}
+
+HX_RESULT CHXExSite::_TestFullScreen( void* hTestBitmap,
+                                        const char* pszStatusText )
+{
+#ifdef _DEBUG
+    fprintf( stderr, "Going to test full screen....\n" );
+#endif
+    return HXR_OK;
+}
+
+void CHXExSite::ProcessEvent(HXxEvent* pEvent)
+{
+    if(pEvent)
+    {
+        //Expose event compression. Combine all outstanding expose events
+        //into one big region.
+        if(Expose==pEvent->event)
+        {
+            _CollapseExposeEvents((XEvent*)pEvent->param2);
+        }
+    }
+
+    //Send the event to each registered UnixSite.
+    void* pSite   = NULL;
+    void* pWindow = NULL;
+    POSITION  pos = z_mapSiteToWindow.GetStartPosition();
+    while( pos )
+    {
+        z_mapSiteToWindow.GetNextAssoc(pos, pSite, pWindow);
+        CHXExSite* pSiteWindowed = (CHXExSite*)pSite;
+        CHXExSite* pTopLevel = NULL;
+        HX_ASSERT(pSiteWindowed);
+        pSiteWindowed->AddRef();
+        pTopLevel = (CHXExSite*)pSiteWindowed->GetTopLevelSite();
+
+        if(pEvent)
+        {
+            //Call back into the basesite's event loop.
+            pTopLevel->EventOccurred(pEvent);
+        }
+
+        //XXXgfw As a workaround for the overlay not moving while the
+        //player is paused, we will check it here and update it if needed.
+
+        //XXXRGG We might be able to use X's ConfigureNotify messages instead
+        //of doing a refresh every 50 ms.
+        pTopLevel->_UpdateOverlayIfNeeded();
+
+        pSiteWindowed->Release();
+    }
+}
+
+void CHXExSite::_CollapseExposeEvents(XEvent* xevent)
+{
+    Display*      display = xevent->xany.display;
+    Window        window  = xevent->xany.window;
+    XExposeEvent* expose_event = (XExposeEvent*)xevent;
+    XEvent        new_event;
+    XExposeEvent* new_expose_event = (XExposeEvent*)&new_event;
+    ushort        x1;
+    ushort        y1;
+    ushort        x2;
+    ushort        y2;
+    ushort        x3;
+    ushort        y3;
+
+    x1 = expose_event->x;
+    y1 = expose_event->y;
+    x2 = x1 + expose_event->width;
+    y2 = y1 + expose_event->height;
+    XLockDisplay(display);
+    HXBOOL status = XCheckWindowEvent(display, window, ExposureMask, &new_event);
+    XUnlockDisplay(display);
+    while( status)
+    {
+        if (new_expose_event->x < x1)
+            x1 = new_expose_event->x;
+
+        if (new_expose_event->y < y1)
+            y1 = new_expose_event->y;
+
+        x3 = new_expose_event->x + new_expose_event->width;
+        if (x3 > x2)
+            x2 = x3;
+
+        y3 = new_expose_event->y + new_expose_event->height;
+        if (y3 > y2)
+            y2 = y3;
+        XLockDisplay(display);
+        status = XCheckWindowEvent(display, window, ExposureMask, &new_event);
+        XUnlockDisplay(display);
+
+    }
+
+    expose_event->x = x1;
+    expose_event->y = y1;
+    expose_event->width = x2 - x1;
+    expose_event->height = y2 - y1;
+    expose_event->count = new_expose_event->count;
+}
+
+
+HXBOOL CHXExSite::_ShouldProcess(HXxEvent* pEvent)
+{
+    HXBOOL bShouldProcessThisEvent = TRUE;
+
+
+    if( !IsSiteVisible() )
+    {
+        switch (pEvent->event)
+        {
+           case ButtonPress:
+           case ButtonRelease:
+           case Expose:
+           case FocusIn:
+               bShouldProcessThisEvent = FALSE;
+               break;
+           default:
+               break;
+        }
+    }
+
+    if(m_pWindow && m_pWindow->window!=pEvent->window)
+    {
+        bShouldProcessThisEvent = FALSE;
+    }
+    return bShouldProcessThisEvent;
+}
+
+
+///////////////////////////////////////////////////////
+//
+// UnixEventHandler methods...
+//
+CHXExSite::UnixEventHandler::UnixEventHandler(CHXExSite* pParent)
+    : m_pParent(pParent),
+      m_lRefCount(0),
+      m_cbHandle(0)
+{
+    HX_ASSERT(m_pParent);
+    HX_ASSERT(m_pParent->m_pScheduler);
+    m_cbHandle = m_pParent->m_pScheduler->RelativeEnter((IHXCallback*)this, 30);
+}
+
+CHXExSite::UnixEventHandler::~UnixEventHandler()
+{
+    CancelCallback();
+}
+
+void
+CHXExSite::UnixEventHandler::CancelCallback()
+{
+    if( m_cbHandle && m_pParent && m_pParent->m_pScheduler )
+    {
+        UINT32 tempHandle = m_cbHandle;
+        m_cbHandle = 0;
+        m_pParent->m_pScheduler->Remove(tempHandle);
+    }
+}
+
+HX_RESULT CHXExSite::UnixEventHandler::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IHXCallback))
+    {
+        AddRef();
+        *ppvObj = (IHXCallback*)this;
+        return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IUnknown))
+    {
+        AddRef();
+        *ppvObj = this;
+        return HXR_OK;
+    }
+
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+ULONG32 CHXExSite::UnixEventHandler::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+ULONG32 CHXExSite::UnixEventHandler::Release()
+{
+    HX_ASSERT(m_lRefCount>0);
+    if( InterlockedDecrement(&m_lRefCount)>0 )
+    {
+        return m_lRefCount;
+    }
+    delete this;
+    return 0;
+}
+
+//IHXCallback methods
+HX_RESULT CHXExSite::UnixEventHandler::Func()
+{
+    XEvent xevent;
+    static HXxEvent pnevent;
+
+    m_cbHandle = 0;
+    XLockDisplay(m_pParent->zm_display);
+    int status = XPending(m_pParent->zm_display);
+    XUnlockDisplay(m_pParent->zm_display);
+    while(status)
+    {
+        XLockDisplay(m_pParent->zm_display);
+        XNextEvent(m_pParent->zm_display, &xevent);
+        XUnlockDisplay(m_pParent->zm_display);
+
+        // package native event in HXxEvent and send to dispatcher
+        pnevent.event = xevent.type;
+        pnevent.window = (void *)xevent.xany.window;
+        pnevent.param1 = xevent.xany.display;
+        pnevent.param2 = &xevent;
+
+        m_pParent->ProcessEvent(&pnevent);
+        XLockDisplay(m_pParent->zm_display);
+        status = XPending(m_pParent->zm_display);
+        XUnlockDisplay(m_pParent->zm_display);
+    }
+
+    if (m_pParent && m_pParent->m_pScheduler)
+    {
+        m_cbHandle = m_pParent->m_pScheduler->RelativeEnter((IHXCallback*)this, 30);
+    }
+    return HXR_OK;
+}
+
+void CHXExSite::_UpdateOverlayIfNeeded()
+{
+    if( m_pVideoSurface )
+    {
+        if( m_pVideoSurface->m_nBltMode == HX_OVERLAY_BLT )
+        {
+            ULONG32 ulNow = HX_GET_BETTERTICKCOUNT();
+            CUnixSurf* pSurf = (CUnixSurf*)m_pVideoSurface;
+            if( ulNow- pSurf->m_ulLastOverlayUpdateTime > 50 )
+            {
+                SiteMoving(0,0);
+            }
+        }
+    }
+    LISTPOSITION pos = m_ChildrenInZOrder.GetHeadPosition();
+    while(pos)
+    {
+        CHXExSite* pSite = (CHXExSite*)m_ChildrenInZOrder.GetNext(pos);
+        pSite->_UpdateOverlayIfNeeded();
+    }
+}
+
+
+HXBOOL  CHXExSite::_ShouldEnterForceRedraw()
+{
+    if( !m_bDamaged || !m_pUser || !IsSiteVisible() )
+    {
+        return FALSE;
+    }
+
+    if(InterlockedIncrement(&m_lBltEntryCount)>1)
+    {
+        InterlockedDecrement(&m_lBltEntryCount);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+void  CHXExSite::_ExitForceRedraw()
+{
+    InterlockedDecrement(&m_lBltEntryCount);
+}
+
Index: helix-libs/clientapps/clutter/exsite.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exsite.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,272 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: unixsite.h,v 1.10.2.3 2008/06/05 14:24:30 lovish Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ *                 Phil Dibowitz (jaymzh)
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef _UNIXSITE_H
+#define _UNIXSITE_H
+
+#if defined(USE_XWINDOWS)
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/Intrinsic.h>
+#include <X11/extensions/XShm.h>
+#endif
+
+#include "basesite.h"
+#include "hxcbobj.h"
+#include "player.h"
+
+class CHXExSite : public CHXBaseSite
+{
+public:
+
+   friend class CExSurf;
+   friend class CExRootSurf;
+   
+   CHXExSite( IUnknown* pContext,
+                IUnknown* pUnkOuter,
+                INT32 lInitialZorder,
+                on_new_frame_cb_t on_new_frame_cb = NULL,
+                void *context = NULL);
+   
+   static void ProcessEvent(HXxEvent* pEvent);
+   Window CreateXWindow( Window win ); 
+
+   void _ForwardUpdateEvent(HXxEvent* pEvent);
+
+   //static member vars.
+   static Display* zm_display;
+   void _UpdateOverlayIfNeeded();
+   HXBOOL m_bIgnoreFocusOutInFS;
+
+   //We override this.
+   void CheckColorSettings();
+
+protected:
+   
+   virtual ~CHXExSite();
+   
+   //
+   // CHXExSite only methods....
+   //
+   HX_RESULT   _OpenXDisplay(char* DiplayString);
+   static void _CollapseExposeEvents(XEvent* xevent);
+   HXBOOL        _ShouldProcess(HXxEvent* pEvent);
+   void        _DrawArrows();
+   void        _CreateHorizScrollBar(void);
+   void        _CreateVertScrollBar(void);
+   HXBOOL        _InButton(HXxPoint& pt, int x, int y );
+   void        _DestroyScrollButtons();
+   void        _MapScrollButtons();
+   void        _MapHorzScroll();
+   void        _MapVertScroll();
+   void        _UnmapHorzScroll();
+   void        _UnmapVertScroll();
+   void        _UnmapScrollButtons();
+   void        _BuildClipRegion();
+   void        _ReleaseClippingRegion();
+
+   //
+   // Seperate object for our callbacks to keep the events flowing.
+   //
+   class UnixEventHandler : public IHXCallback
+   {
+   public:
+      UnixEventHandler(CHXExSite* pParent);
+        
+      //IUnknown methods
+      virtual HX_RESULT QueryInterface(REFIID riid, void** ppvObj);
+      virtual ULONG32 AddRef();
+      virtual ULONG32 Release();
+
+      //IHXCallback methods
+      virtual HX_RESULT Func(); 
+      void CancelCallback();
+        
+   private:
+      virtual ~UnixEventHandler();
+       
+      UnixEventHandler();
+      UnixEventHandler(const UnixEventHandler&);
+      UnixEventHandler& operator=(const UnixEventHandler& it );
+        
+      CHXExSite*   m_pParent;
+      LONG32         m_lRefCount;
+      CallbackHandle m_cbHandle;
+
+      IUnknown* m_pUnkPlayer;
+   };
+    
+
+   //
+   // CHXBaseSite inherited methods
+   //
+   virtual void  _NeedWindowedSite();
+   virtual void  _AttachWindow();
+   virtual void  _DetachWindow();
+   virtual void* _Create(void* ParentWindow, UINT32 style);
+   virtual void  _Destroy(HXxWindow* pWindow); 
+   virtual void  _SetSize(HXxSize size); 
+   virtual void  _SetPosition(HXxPoint position); 
+   virtual void  _DamageRect(HXxRect rect);
+   virtual void  _DamageRegion(HXxRegion rect);
+   virtual HXBOOL  _ShouldEnterForceRedraw(); 
+   virtual void  _ExitForceRedraw(); 
+   virtual void  _SendOSUpdateMessage(); 
+   virtual void  _ShowSite(HXBOOL bShow); 
+   virtual HXBOOL  _AtSystemTime(); 
+   virtual void  _GetDeviceCaps( void* hdc,
+                                 UINT16& uBitesPerPixel,
+                                 UINT16& uHorzRes,
+                                 UINT16& uVertRes ); 
+   virtual void  _GetWindowRect(HXxRect* destRect);
+   virtual void  _DestroySliders();
+   virtual HXBOOL  _HandleOSEvents(HXxEvent* pEvent);
+   virtual HXBOOL  _ConvertToHXEvent(HXxEvent* pEvent);
+   virtual void  _GenerateOSEvent(HXxEvent* pEvent, HXxEvent* pEvent2);
+   virtual void  _GenerateSetCursorEvent();
+   virtual void  _TryCreateXSlider();
+   virtual void  _SetXSliderValues(INT32 range, INT32 pageSize);
+   virtual void  _TryCreateYSlider();
+   virtual void  _SetYSliderValues(INT32 range, INT32 pageSize);
+   virtual void  _GetSystemSizeOfSliders(INT32* pWidth, INT32* pHeight);
+   virtual HXBOOL  _IsWindowVisible();
+   virtual void  _ShowXSlider(HXBOOL bShow);
+   virtual void  _MoveXSlider( INT32 left,
+                               INT32 top,
+                               INT32 right,
+                               INT32 bottom,
+                               HXBOOL bRedraw );
+   virtual void  _ShowYSlider(HXBOOL bShow);
+   virtual void  _MoveYSlider( INT32 left,
+                               INT32 top,
+                               INT32 right,
+                               INT32 bottom,
+                               HXBOOL bRedraw);
+   virtual HXBOOL  _DoesXSliderExist();
+   virtual void* _GetContainingWindow();
+   virtual void  _GetCursorPos(HXxPoint* pPoint);
+   virtual void  _MapPointToOSWindow(HXxPoint* pPt, void** pWindowHandle);
+   virtual void* _GetWindowWithCursor();
+   virtual void  _ReInitPrimarySurface();
+   virtual HXBOOL  _MoveWindow( void* ,
+                              INT32 X,
+                              INT32 Y,
+                              INT32 nWidth,
+                              INT32 nHeight,
+                              HXBOOL bRepaint);
+   virtual HXBOOL  _UpdateWindow(void* hWnd);
+   virtual HXBOOL  _ShowWindow(void* hWnd, INT32 nCmdShow);
+   virtual HXBOOL  _SetWindowPos(void* hWnd,
+                               void* hWndInsertAfter,
+                               INT32 X,
+                               INT32 Y,
+                               INT32 cx,
+                               INT32 cy,
+                               INT32 uFlags);
+   virtual HXBOOL  _SetWindowRgn(void* hWnd, HXREGION* hRgn, HXBOOL bRedraw);
+   virtual void _SetFocus(void* pWindow);
+    
+   virtual HX_RESULT _EnterFullScreen(HXxWindow* pWindow = NULL);
+   virtual HX_RESULT _EventOccurred(HXxEvent* pEvent);
+   virtual HX_RESULT _ExitFullScreen();
+   virtual HX_RESULT _TestFullScreen( void* hTestBitmap,
+                                      const char* pszStatusText );
+   virtual HX_RESULT _EnterFullScreenExt(HXxWindow* pWindow, IHXValues* pValues);
+   virtual HX_RESULT _ExitFullScreenExt();
+#if defined(HELIX_CONFIG_MOBLIN)
+   static void	        AttachWindowCallback(void *pParam);
+   static void	        ForceRedrawCallback(void *pParam);
+   void                    RemovePendingCallback(CHXGenericCallback* pCB);
+   
+   CHXGenericCallback*     m_pAttachWindowCallback;
+   CHXGenericCallback*     m_pForceRedrawCallback;
+#endif   
+   HXBOOL                  m_bReparent;   
+
+private:
+
+   //Protect unintentional copy and default ctors.
+   CHXExSite();
+   CHXExSite( const CHXExSite& );
+   CHXExSite& operator=( const CHXExSite& it );
+   HX_RESULT _EnterFullScreenNoNewWindow();
+    
+   //member vars.
+   UnixEventHandler* m_pUnixEventHandler;
+   static Cursor zm_GrabCursor;
+   Window        m_ScrollHorizButtonL;
+   Window        m_ScrollHorizButtonR;
+   Window        m_ScrollVertButtonT;
+   Window        m_ScrollVertButtonB;
+   Window        m_winFullScreenWindow;
+   Window        m_winOldParent;
+   HXxPoint      m_ptScrollHorizPosL;
+   HXxPoint      m_ptScrollHorizPosR;
+   HXxPoint      m_ptScrollVertPosT;
+   HXxPoint      m_ptScrollVertPosB;
+   HXxPoint      m_ptFullScreenOffset;
+   HXxSize       m_PreFullScreenSize;
+   HXBOOL          m_bScrollingInProgress;
+   int           m_nScrollDir;
+   HXBOOL          m_bLastPointInSite;
+   HXBOOL          m_bDamaged;
+   //
+   //Private helpers...
+   //
+
+   //returns the HX_VK associated with this keysym....
+   UINT32 _MapKeySymToHXVK(KeySym tmpSym, UINT32& uFlags);
+   on_new_frame_cb_t m_on_new_frame_cb;
+   void *m_context;
+};
+
+#endif //_UNIXSITE_H
Index: helix-libs/clientapps/clutter/exsitsup.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exsitsup.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,455 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifdef _WIN16
+#include <windows.h>
+#endif
+
+#include "hxcom.h"
+#include "hxtypes.h"
+#include "hxwintyp.h"
+#include "hxwin.h"
+#include "ihxpckts.h"
+#include "hxcomm.h"
+#include "fivemmap.h"
+#include "hxstring.h" // CHXString
+#include "exsite.h"
+#include "exsitsup.h"
+#include "pckunpck.h" // CreateBufferCCF
+#include "ciddefs.h"  // CID_RGB32
+#if defined(HELIX_FEATURE_PNG)
+#include "pxpngenc.h" // PXPNGEncode::EncodeToPNGBuffer
+#endif //  HELIX_FEATURE_PNG
+#include "print.h"
+
+
+#include "globals.h"
+struct _stGlobals*& GetGlobal();
+
+/************************************************************************
+ *  Method:
+ *    Constructor
+ */
+	ExampleSiteSupplier::ExampleSiteSupplier(IUnknown* pUnkPlayer, on_new_frame_cb_t on_new_frame_cb = NULL, void *context = NULL)
+	: m_lRefCount(0)
+	, m_pSiteManager(NULL)
+	, m_pSite(NULL)
+	, m_pSiteCapture(NULL)
+	, m_pCaptureBuffer(NULL)
+	, m_pCCF(NULL)
+	  , m_pUnkPlayer(pUnkPlayer)
+	  , m_on_new_frame_cb(on_new_frame_cb)
+      , m_context(context)
+{
+	if (m_pUnkPlayer)
+	{
+		m_pUnkPlayer->QueryInterface(IID_IHXSiteManager,
+				(void**)&m_pSiteManager);
+
+		//printf("pauldebug:m_pUnkplayer->QueryInterface for m_pCCF calling\n");
+		m_pUnkPlayer->QueryInterface(IID_IHXCommonClassFactory,
+				(void**)&m_pCCF);
+		//printf("pauldebug:m_pUnkplayer->QueryInterface for m_pCCF called\n");
+
+		m_pUnkPlayer->AddRef();
+	}
+};
+
+/************************************************************************
+ *  Method:
+ *    Destructor
+ */
+ExampleSiteSupplier::~ExampleSiteSupplier()
+{
+	HX_RELEASE(m_pSiteManager);
+	HX_RELEASE(m_pSite);
+	HX_RELEASE(m_pSiteCapture);
+	HX_RELEASE(m_pCaptureBuffer);
+	HX_RELEASE(m_pCCF);
+	HX_RELEASE(m_pUnkPlayer);
+}
+
+/************************************************************************
+ *  Method:
+ *    IUnknown::QueryInterface
+ */
+	STDMETHODIMP 
+ExampleSiteSupplier::QueryInterface(REFIID riid, void** ppvObj)
+{
+	if (IsEqualIID(riid, IID_IUnknown))
+	{
+		AddRef();
+		*ppvObj = (IUnknown*)(IHXSiteSupplier*)this;
+		return HXR_OK;
+	}
+	else if (IsEqualIID(riid, IID_IHXSiteSupplier))
+	{
+		AddRef();
+		*ppvObj = (IHXSiteSupplier*)this;
+		return HXR_OK;
+	}
+
+	*ppvObj = NULL;
+	return HXR_NOINTERFACE;
+}
+
+/************************************************************************
+ *  Method:
+ *    IUnknown::AddRef
+ */
+	STDMETHODIMP_(ULONG32) 
+ExampleSiteSupplier::AddRef()
+{
+	return InterlockedIncrement(&m_lRefCount);
+}
+
+/************************************************************************
+ *  Method:
+ *    IUnknown::Release
+ */
+	STDMETHODIMP_(ULONG32) 
+ExampleSiteSupplier::Release()
+{
+	if (InterlockedDecrement(&m_lRefCount) > 0)
+	{
+		return m_lRefCount;
+	}
+
+	delete this;
+	return 0;
+}
+
+/************************************************************************
+ *  Method:
+ *    IHXSiteSupplier::SitesNeeded
+ *  Purpose:
+ *    Called to inform the site supplier that a site with a particular
+ *    set of characteristics is needed. If the site supplier can 
+ *    fulfill the request it should call the site manager and add one
+ *    or more new sites.
+ *    Note that the request for sites is associated with a Request ID
+ *    the client core will inform the site supplier when this requested
+ *    site is no longer needed.
+ */
+STDMETHODIMP 
+ExampleSiteSupplier::SitesNeeded
+(
+ UINT32	uRequestID,
+ IHXValues*	pProps
+ )
+{
+	/*
+	 * Don't create a site if the -NULL_RENDER command line option
+	 * was given. - jfarr
+	 */
+	if (GetGlobal()->g_bNullRender)
+	{
+		return (HXR_OK);
+	}
+
+	/*
+	 * If there are no properties, then we can't really create a
+	 * site, because we have no idea what type of site is desired!
+	 */
+	if (!pProps)
+	{
+		return HXR_INVALID_PARAMETER;
+	}
+
+	HRESULT		hres		= HXR_OK;
+	IHXValues*		pSiteProps	= NULL;
+	IHXSiteWindowed*	pSiteWindowed	= NULL;
+	IHXBuffer*		pValue		= NULL;
+	UINT32		style		= 0;
+	IHXSite*		pSite		= NULL;
+
+#if 0
+	// Just let the RMA client core create a windowed site for us.
+	hres = m_pCCF->CreateInstance(CLSID_IHXSiteWindowed,(void**)&pSiteWindowed);
+	if (HXR_OK != hres)
+	{
+		goto exit;
+	}
+#else
+	{
+		*(void **)&pSiteWindowed = (IUnknown*)(IHXSiteWindowed*)(new CHXExSite(GetGlobal()->pMediaPlatform, NULL, 0, m_on_new_frame_cb, m_context));
+		hres = ((IUnknown*)*(void **)&pSiteWindowed)->QueryInterface(IID_IHXSiteWindowed, (void**)&pSiteWindowed);
+		if (HXR_OK != hres)
+		{
+			goto exit;
+		}
+	}
+#endif
+
+	hres = pSiteWindowed->QueryInterface(IID_IHXSite,(void**)&pSite);
+	if (HXR_OK != hres)
+	{
+		goto exit;
+	}
+
+	if( !m_pSite )
+	{
+		m_pSite = pSite;
+		m_pSite->AddRef();
+	}
+
+
+	hres = pSiteWindowed->QueryInterface(IID_IHXValues,(void**)&pSiteProps);
+	if (HXR_OK != hres)
+	{
+		goto exit;
+	}
+
+	/*
+	 * We need to figure out what type of site we are supposed to
+	 * to create. We need to "switch" between site user and site
+	 * properties. So look for the well known site user properties
+	 * that are mapped onto sites...
+	 */
+	hres = pProps->GetPropertyCString("playto",pValue);
+	if (HXR_OK == hres)
+	{
+		pSiteProps->SetPropertyCString("channel",pValue);
+		HX_RELEASE(pValue);
+	}
+	else
+	{
+		hres = pProps->GetPropertyCString("name",pValue);
+		if (HXR_OK == hres)
+		{
+			pSiteProps->SetPropertyCString("LayoutGroup",pValue);
+			HX_RELEASE(pValue);
+		}
+	}
+
+#ifdef _WINDOWS
+	style = WS_OVERLAPPED | WS_VISIBLE | WS_CLIPCHILDREN;
+#endif
+
+	hres = pSiteWindowed->Create(NULL, style);
+	if (HXR_OK != hres)
+	{
+		goto exit;
+	}
+
+	/*
+	 * We need to wait until we have set all the properties before
+	 * we add the site.
+	 */
+	hres = m_pSiteManager->AddSite(pSite);
+	if (HXR_OK != hres)
+	{
+		goto exit;
+	}
+#ifdef _WINDOWS
+	{
+		HXxWindow* pWindow = pSiteWindowed->GetWindow();
+		if (pWindow && pWindow->window) ::SetForegroundWindow( (HWND)(pWindow->window) );
+	}
+#endif
+	m_CreatedSites.SetAt((void*)uRequestID,pSite);
+	pSite->AddRef();
+
+exit:
+
+	HX_RELEASE(pSiteProps);
+	HX_RELEASE(pSiteWindowed);
+	HX_RELEASE(pSite);
+
+	return hres;
+}
+
+/************************************************************************
+ *  Method:
+ *    IHXSiteSupplier::SitesNotNeeded
+ *  Purpose:
+ *    Called to inform the site supplier that all sites from a previos
+ *    site request are no longer needed. If the site supplier had 
+ *    previously created non-persistant sites (like popup windows)
+ *    to fulfill a request for sites it should call the site manager 
+ *    and remove those sites.
+ */
+STDMETHODIMP 
+ExampleSiteSupplier::SitesNotNeeded(UINT32 uRequestID)
+{
+    IHXSite*		pSite = NULL;
+    IHXSiteWindowed*	pSiteWindowed = NULL;
+    void*		pVoid = NULL;
+
+    if (!m_CreatedSites.Lookup((void*)uRequestID,pVoid))
+    {
+	return HXR_INVALID_PARAMETER;
+    }
+    pSite = (IHXSite*)pVoid;
+
+    m_pSiteManager->RemoveSite(pSite);
+
+    // Need to actually do the work on destroying the window
+    // and all that jazz.
+    pSite->QueryInterface(IID_IHXSiteWindowed,(void**)&pSiteWindowed);
+
+    pSiteWindowed->Destroy();
+
+    // ref count = 2
+    pSiteWindowed->Release();
+
+    // ref count = 1; deleted from this object's view!
+    pSite->Release();
+
+    m_CreatedSites.RemoveKey((void*)uRequestID);
+
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *    IHXSiteSupplier::BeginChangeLayout
+ *  Purpose:
+ *    Called to inform the site supplier a layout change has beginning
+ *    it can expect to recieve SitesNeeded() and SitesNotNeeded() calls
+ *    while a layout change is in progress,
+ */
+STDMETHODIMP 
+ExampleSiteSupplier::BeginChangeLayout()
+{
+    return HXR_OK;
+}
+
+/************************************************************************
+ *  Method:
+ *    IHXSiteSupplier::DoneChangeLayout
+ *  Purpose:
+ *    Called to inform the site supplier the layout change has been
+ *    completed.
+ */
+STDMETHODIMP 
+ExampleSiteSupplier::DoneChangeLayout()
+{
+    return HXR_OK;
+}
+
+HX_RESULT
+ExampleSiteSupplier::CaptureImage(CHXString pszFileName, INT32 dWidth, INT32 dHeight)
+{
+    HX_RESULT res=HXR_FAIL;
+
+    // Get the IHXSiteCapture object from the site
+    if (m_pSiteCapture == NULL)
+    {
+	if (m_pSite && m_pSite->QueryInterface(IID_IHXSiteCapture, (void**)&m_pSiteCapture) == HXR_OK)
+	{
+	    m_pSiteCapture->AddRef();
+	}
+    }
+
+    // Create the buffer that will receive the image data
+    if (m_pCaptureBuffer == NULL)
+    {
+    	CreateBufferCCF(m_pCaptureBuffer, m_pCCF);
+	if (!m_pCaptureBuffer)
+	{
+	    return HXR_OUTOFMEMORY;
+	}
+    }
+
+    HXBOOL bCanCapture = FALSE;
+
+    // Check if the site is available to capture an image
+    if (m_pSiteCapture && (res = m_pSiteCapture->CanCapture(bCanCapture)) == HXR_OK && bCanCapture)
+    {
+	HX_RESULT res;
+	HXxSize outputSize;
+	outputSize.cx  = dWidth;
+	outputSize.cy  = dHeight;
+	m_strFileName = pszFileName;
+
+	// Asynchronous call. CaptureDone() will be called with result.
+	res = m_pSiteCapture->Capture((IHXSiteCaptureResponse*)this, m_pCaptureBuffer, &outputSize, CID_RGB32);
+    }
+
+    return res;
+
+}
+
+//
+// IHXSiteCaptureResponse::CaptureDone
+//
+// Called when the site has captured the next frame.
+// bmiOutputFormat points to image format description which
+// is valid until the completion of CaptureDone.
+// bmiOutputFormat can be different for every capture.
+// pCaptureBuffer holds the image if supplied in
+// Capture() method.  pCaptureBuffer is automatically
+// resized if it has insufficient size to hold the image
+// data.
+//
+// status may be:
+//   HXR_FAIL  -- No capture was done. General Error. All data is invalid.
+//   HXR_OK    -- Capture was done. Both variables are valid.
+STDMETHODIMP
+ExampleSiteSupplier::CaptureDone(REF(HX_RESULT) status,
+			REF(HXBitmapInfoHeader) bmiOutputFormat,
+			REF(IHXBuffer*) pCaptureBuffer)
+{
+    if (status == HXR_OK)
+    {
+#if defined(HELIX_FEATURE_PNG)
+	// Convert capture buffer into PNG
+	IHXBuffer* pConvertedBuffer=NULL;
+	HX_RESULT res = HXR_OK;
+	res = PXPNGEncode::EncodeToPNGBuffer(pCaptureBuffer, &bmiOutputFormat, m_pCCF, pConvertedBuffer);
+	if (res == HXR_OK && !m_strFileName.IsEmpty())
+	{
+	    CHXString strTail = m_strFileName.Right(4);
+	    if (strTail.CompareNoCase(".png") != 0)
+	    {
+		m_strFileName += ".png";
+	    }
+
+	    FILE* fp = fopen(m_strFileName, "wb");
+	    if (fp)
+	    {
+	        fwrite(pConvertedBuffer->GetBuffer(), 1, pConvertedBuffer->GetSize(), fp);
+	        fclose(fp);
+		STDOUT("Captured image to PNG file: %s\n", (const char*)m_strFileName);
+		STDOUT("File size: %ld\n", pConvertedBuffer->GetSize());
+	    }
+	    HX_RELEASE(pConvertedBuffer);
+	}
+#endif //  HELIX_FEATURE_PNG
+    }
+
+    return status;
+}
Index: helix-libs/clientapps/clutter/exsitsup.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exsitsup.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,154 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXSITSUP_H_
+#define _EXSITSUP_H_
+
+#include "fivemmap.h"
+#include "player.h"
+
+/****************************************************************************
+ * 
+ *  Class:
+ *
+ *	ExampleSiteSupplier
+ *
+ *  Purpose:
+ *
+ *	Implementation for ragui's IHXSiteSupplier
+ *
+ */
+class ExampleSiteSupplier : 
+	public IHXSiteSupplier
+	, public IHXSiteCaptureResponse
+{
+private:
+    LONG32		    m_lRefCount;
+    IHXSiteManager*	    m_pSiteManager;
+    IHXSite*		    m_pSite;
+    IHXSiteCapture*	    m_pSiteCapture;
+    IHXBuffer*		    m_pCaptureBuffer;
+    IHXCommonClassFactory*  m_pCCF;
+    IUnknown*		    m_pUnkPlayer;
+    FiveMinuteMap	    m_CreatedSites;
+    CHXString		    m_strFileName;
+    on_new_frame_cb_t   m_on_new_frame_cb;
+    void *              m_context;
+
+    ~ExampleSiteSupplier();
+
+public:
+    ExampleSiteSupplier(IUnknown* pUnkPlayer, on_new_frame_cb_t new_frame_cb = NULL, void *context = NULL);
+    
+    /*
+     * IUnknown methods
+     */
+    STDMETHOD(QueryInterface)	(THIS_
+				REFIID riid,
+				void** ppvObj);
+
+    STDMETHOD_(ULONG32,AddRef)	(THIS);
+
+    STDMETHOD_(ULONG32,Release)	(THIS);
+
+    /*
+     * IHXSiteSupplier methods
+     */
+
+    /************************************************************************
+     *	Method:
+     *	    IHXSiteSupplier::SitesNeeded
+     *	Purpose:
+     *	  Called to inform the site supplier that a site with a particular
+     *	  set of characteristics is needed. If the site supplier can 
+     *	  fulfill the request it should call the site manager and add one
+     *	  or more new sites.
+     *    Note that the request for sites is associated with a Request ID
+     *    the client core will inform the site supplier when this requested
+     *    site is no longer needed.
+     */
+    STDMETHOD(SitesNeeded)	(THIS_
+				UINT32			uRequestID,
+				IHXValues*		pSiteProps);
+
+    /************************************************************************
+     *  Method:
+     *    IHXSiteSupplier::SitesNotNeeded
+     *  Purpose:
+     *    Called to inform the site supplier that all sites from a previos
+     *	  site request are no longer needed. If the site supplier had 
+     *	  previously created non-persistant sites (like popup windows)
+     *    to fulfill a request for sites it should call the site manager 
+     *    and remove those sites.
+     */
+    STDMETHOD(SitesNotNeeded)
+				(THIS_
+				UINT32			uRequestID);
+
+
+    /************************************************************************
+     *  Method:
+     *    IHXSiteSupplier::BeginChangeLayout
+     *  Purpose:
+     *    Called to inform the site supplier a layout change has beginning
+     *	  it can expect to recieve SitesNeeded() and SitesNotNeeded() calls
+     *	  while a layout change is in progress,
+     */
+    STDMETHOD(BeginChangeLayout) (THIS);
+
+    /************************************************************************
+     *  Method:
+     *    IHXSiteSupplier::DoneChangeLayout
+     *  Purpose:
+     *    Called to inform the site supplier the layout change has been
+     *	  completed.
+     */
+    STDMETHOD(DoneChangeLayout) (THIS);
+
+    /*
+     * IHXSiteCaptureResponse
+     */
+    STDMETHOD(CaptureDone)	(THIS_
+				REF(HX_RESULT) 		 status,
+                        	REF(HXBitmapInfoHeader)  bmiOutputFormat,
+                        	REF(IHXBuffer*)          pImageDataBuffer
+				);
+
+    HX_RESULT CaptureImage(CHXString pFileName, INT32 dWidth, INT32 dHeight);
+
+};
+
+#endif // _EXSITSUP_H_
+
Index: helix-libs/clientapps/clutter/exstateadvsnk.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exstateadvsnk.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,229 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include <stdio.h>
+
+#include "hxtypes.h"
+
+#include "hxcom.h"
+#include "hxcomm.h"
+#include "hxmon.h"
+#include "hxcore.h"
+#include "hxengin.h"
+#include "hxclsnk.h"
+#include "hxgroup.h"
+#include "hxstrutl.h"
+#include "exstateadvsnk.h"
+#include "hxstring.h"
+#include "hxprefs.h"
+#include "excontxt.h"
+
+#include "print.h"
+
+#include "globals.h"
+#include "player.h"
+
+struct _stGlobals*& GetGlobal(); //in main.cpp
+
+#ifdef __TCS__
+extern unsigned long   gStreamTime;
+ 
+static int		iOpened = 0;
+
+
+#if	defined(__cplusplus)
+extern	"C"	{
+#endif	/* defined(__cplusplus) */
+
+typedef enum hookBuffering {
+	eContacting = 0,
+	eConnecting = 1,
+	eBuffering = 2,
+	ePlaying = 3
+}hookBuffering;
+
+void hookRealAudio_Buffering(hookBuffering connectState, int pct);
+
+void hookRealAudio_PlayPosition(unsigned long current,unsigned long duration);
+
+typedef enum hookState {
+	ePlay = 0,
+	ePause = 1,
+	eStop = 2,
+	eResume = 3,
+	eComplete				// Clip is done playing
+}hookState;
+void hookRealAudio_State(hookState newState);
+
+
+#if	defined(__cplusplus)
+}
+#endif	/* defined(__cplusplus) */
+
+#endif // __TCS__
+
+void PrintBuffer(const char* pszName,const unsigned char* pbBuf, unsigned int dwBytes);
+
+ExampleClientStateAdviceSink::ExampleClientStateAdviceSink(IUnknown* pUnknown, LONG32 lClientIndex, on_state_change_cb_t on_state_change_cb, void *context)
+    : m_lRefCount (0)
+    , m_lClientIndex (lClientIndex)
+    , m_pUnknown (NULL)
+    , m_State (HX_CLIENT_STATE_READY)
+    , m_state_change_cb(on_state_change_cb)
+    , m_context(context)
+{
+    if (pUnknown)
+    {
+        m_pUnknown = pUnknown;
+        m_pUnknown->AddRef();
+
+        IHXPlayer* pPlayer;
+        IHXClientStateAdviseSinkControl *pStateControl;
+        if(HXR_OK == m_pUnknown->QueryInterface(IID_IHXPlayer,
+                    (void**)&pPlayer))
+        {
+            m_pPlayer = pPlayer;
+
+
+        }
+
+        if (HXR_OK == m_pUnknown->QueryInterface(IID_IHXClientStateAdviseSinkControl, (void **)&pStateControl))
+        {
+            pStateControl->AddClientStateAdviseSink(this);
+        }
+    }
+
+#ifdef __TCS__
+    bEnableAdviceSink = TRUE;
+    iOpened = 0;
+#endif 
+}
+
+ExampleClientStateAdviceSink::~ExampleClientStateAdviceSink(void)
+{
+
+    if (m_pPlayer)
+    {
+	m_pPlayer->Release();
+	m_pPlayer = NULL;
+    }
+    if (m_pUnknown)
+    {
+	m_pUnknown->Release();
+	m_pUnknown = NULL;
+    }
+}
+
+
+// *** IUnknown methods ***
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::QueryInterface
+//  Purpose:
+//	Implement this to export the interfaces supported by your 
+//	object.
+//
+STDMETHODIMP ExampleClientStateAdviceSink::QueryInterface(REFIID riid, void** ppvObj)
+{
+    if (IsEqualIID(riid, IID_IUnknown))
+    {
+	AddRef();
+	*ppvObj = (IUnknown*)(IHXClientStateAdviseSink *)this;
+	return HXR_OK;
+    }
+    else if (IsEqualIID(riid, IID_IHXClientStateAdviseSink))
+    {
+	AddRef();
+	*ppvObj = (IHXClientStateAdviseSink*)this;
+	return HXR_OK;
+    }
+
+    *ppvObj = NULL;
+    return HXR_NOINTERFACE;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::AddRef
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleClientStateAdviceSink::AddRef()
+{
+    return InterlockedIncrement(&m_lRefCount);
+}
+
+/////////////////////////////////////////////////////////////////////////
+//  Method:
+//	IUnknown::Release
+//  Purpose:
+//	Everyone usually implements this the same... feel free to use
+//	this implementation.
+//
+STDMETHODIMP_(ULONG32) ExampleClientStateAdviceSink::Release()
+{
+    if (InterlockedDecrement(&m_lRefCount) > 0)
+    {
+        return m_lRefCount;
+    }
+
+    delete this;
+    return 0;
+}
+
+
+/************************************************************************
+ *      Method:
+ *          IHXClientStateAdviseSink::OnStateChange
+ *      Purpose:
+ *          Called to advise the client state has changed state
+ */
+STDMETHODIMP ExampleClientStateAdviceSink::OnStateChange(UINT16 uOldState, UINT16 uNewState)
+{
+    if (m_state_change_cb)
+        m_state_change_cb(uOldState, uNewState, m_context);
+
+    m_State = uNewState;
+    return HXR_OK;
+}
+
+EHXClientState ExampleClientStateAdviceSink::GetState()
+{
+    return m_State;
+}
+
+
Index: helix-libs/clientapps/clutter/exstateadvsnk.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/exstateadvsnk.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,108 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _EXAMPLE_CLIENT_STATE_ADVISE_SNK_H_
+#define _EXAMPLE_CLIENT_STATE_ADVISE_SNK_H_
+
+#include "player.h"
+
+struct IHXClientStateAdviseSink;
+struct IHXGroupSink;
+struct IUnknown;
+struct IHXRegistry;
+struct IHXScheduler;
+struct IHXCallback;
+struct IHXPlayer;
+struct IHXGroup;
+
+class ExampleClientStateAdviceSink : public IHXClientStateAdviseSink
+{
+    private:
+        LONG32          m_lRefCount;
+        LONG32          m_lClientIndex;
+
+        IUnknown*       m_pUnknown;
+
+        UINT32          m_ulStartTime;
+        UINT32          m_ulStopTime;
+
+        UINT32    m_lCurrentBandwidth;
+        UINT32    m_lAverageBandwidth;
+        HXBOOL      m_bOnStop;
+
+        HXBOOL      m_bWaitForTrackStart;
+
+        on_state_change_cb_t m_state_change_cb;
+        void *m_context;
+        EHXClientState m_State;
+
+        // IHXCallback
+        IHXPlayer*		m_pPlayer;
+        ULONG32         m_hCallback;
+        ~ExampleClientStateAdviceSink();
+
+
+    public:
+
+        ExampleClientStateAdviceSink(IUnknown* /*IN*/ pUnknown, LONG32 /*IN*/ lClientIndex, on_state_change_cb_t on_state_change_cb = NULL, void *context = NULL);
+
+        /*
+         *  IUnknown methods
+         */
+        STDMETHOD(QueryInterface) (THIS_
+                REFIID riid,
+                void** ppvObj);
+
+        STDMETHOD_(ULONG32,AddRef) (THIS);
+
+        STDMETHOD_(ULONG32,Release) (THIS);
+
+        /***********************************************************************
+         *  Method:
+         *     IHXClientStateAdviseSink::OnStateChange
+         *    Purpose:
+         *       Called by client engine to inform the client that the state has changed.
+         *      States are defined in the enum EHXClientState, defined in this file.
+         *
+         */
+        STDMETHOD(OnStateChange)    (THIS_
+                UINT16 uOldState,
+                UINT16 uNewState
+                ) ;
+
+        EHXClientState GetState();
+};
+
+#endif /* _EXAMPLECLSNK_ */
Index: helix-libs/clientapps/clutter/fivemmap.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/fivemmap.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,175 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include <string.h>
+#include "hxtypes.h"
+#include "fivemmap.h"
+
+void* FiveMinuteMap::GetFirstValue()
+{
+    m_nCursor = 0;
+
+    if (m_nMapSize)
+    {
+       return m_pValueArray[m_nCursor];
+    }
+    else
+    {
+       return NULL;
+    }
+}
+
+void* FiveMinuteMap::GetNextValue()
+{
+    m_nCursor++;
+
+    if (m_nCursor < m_nMapSize)
+    {
+       return m_pValueArray[m_nCursor];
+    }
+    else
+    {
+       return NULL;
+    }
+}
+
+HXBOOL FiveMinuteMap::Lookup(void* Key, void*& Value) const
+{
+    HXBOOL bFound = FALSE;
+    int nIndex = 0;
+
+    // If Key is alrady in the list, replace value
+    for (; nIndex < m_nMapSize; nIndex++)
+    {
+	if (m_pKeyArray[nIndex] == Key)
+	{
+	    Value = m_pValueArray[nIndex];
+	    bFound = TRUE;
+	    goto exit;
+	}
+    }
+
+exit:
+    return bFound;    
+}
+
+void FiveMinuteMap::RemoveKey(void* Key)
+{
+    HXBOOL bFound = FALSE;
+    int nIndex = 0;
+
+    // If Key is alrady in the list, replace value
+    for (; nIndex < m_nMapSize; nIndex++)
+    {
+	if (m_pKeyArray[nIndex] == Key)
+	{
+	    if (nIndex < (m_nMapSize-1))
+	    {
+		memmove(&(m_pKeyArray[nIndex]),&(m_pKeyArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1)));
+		memmove(&(m_pValueArray[nIndex]),&(m_pValueArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1)));
+	    }
+	    m_nMapSize--;
+	    goto exit;
+	}
+    }
+
+exit:
+    (NULL); // We're done!
+}
+
+void FiveMinuteMap::RemoveValue(void* Value)
+{
+    HXBOOL bFound = FALSE;
+    int nIndex = 0;
+
+    // If Value is alrady in the list, replace value
+    for (; nIndex < m_nMapSize; nIndex++)
+    {
+	if (m_pValueArray[nIndex] == Value)
+	{
+	    if (nIndex < (m_nMapSize-1))
+	    {
+		memmove(&(m_pKeyArray[nIndex]),&(m_pKeyArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1)));
+		memmove(&(m_pValueArray[nIndex]),&(m_pValueArray[nIndex+1]),sizeof(void*)*(m_nMapSize-(nIndex+1)));
+	    }
+	    m_nMapSize--;
+	    goto exit;
+	}
+    }
+
+exit:
+    (NULL); // We're done!
+}
+
+
+void FiveMinuteMap::SetAt(void* Key, void* Value)
+{
+    int nIndex = 0;
+
+    // If Key is alrady in the list, replace value
+    for (; nIndex < m_nMapSize; nIndex++)
+    {
+	if (m_pKeyArray[nIndex] == Key)
+	{
+	    m_pValueArray[nIndex] = Value;
+	    goto exit;
+	}
+    }
+
+    // If we have room, add it to the end!
+    if (m_nAllocSize == m_nMapSize)
+    {
+	m_nAllocSize += AllocationSize;
+	void** pNewKeys   = new void*[m_nAllocSize];
+	void** pNewValues = new void*[m_nAllocSize];
+
+	memcpy(pNewKeys,m_pKeyArray,sizeof(void*)*m_nMapSize); /* Flawfinder: ignore */
+	memcpy(pNewValues,m_pValueArray,sizeof(void*)*m_nMapSize); /* Flawfinder: ignore */
+
+	delete [] m_pKeyArray;
+	delete [] m_pValueArray;
+
+	m_pKeyArray = pNewKeys;
+	m_pValueArray = pNewValues;
+    }
+
+    m_pKeyArray[m_nMapSize] = Key;
+    m_pValueArray[m_nMapSize] = Value;
+    m_nMapSize++;
+
+exit:
+    (NULL); // We're done!
+}
+
Index: helix-libs/clientapps/clutter/fivemmap.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/fivemmap.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,79 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef _FIVEMMAP_H_
+#define _FIVEMMAP_H_
+
+#ifndef _HXTYPES_H_
+#error FiveMinuteMap assumes pntypes.h.
+#endif
+
+class FiveMinuteMap
+{
+    const int AllocationSize;
+
+    void**  m_pKeyArray;
+    void**  m_pValueArray;
+    int	    m_nMapSize;
+    int	    m_nAllocSize;
+    int     m_nCursor;
+public:
+    FiveMinuteMap()
+	: m_pKeyArray(NULL)
+	, m_pValueArray(NULL)
+	, m_nMapSize(0)
+	, m_nAllocSize(0)
+        , m_nCursor(0)
+	, AllocationSize(10)
+	{};
+
+    ~FiveMinuteMap()
+	{
+	    delete [] m_pKeyArray;
+	    delete [] m_pValueArray;
+	};
+
+    int  GetCount() {return m_nMapSize;}
+
+    void* GetFirstValue();
+    void* GetNextValue();
+
+    HXBOOL Lookup(void* Key, void*& Value) const;
+    void RemoveKey(void* Key);
+    void RemoveValue(void* Value);
+    void SetAt(void* Key, void* Value);
+};
+
+#endif /* _FIVEMMAP_H_ */
Index: helix-libs/clientapps/clutter/globals.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/globals.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,150 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+/****************************************************************************
+ * 
+ *  Test Client:
+ *  
+ *
+ *  This is an test client running on Windows, Mac, and Unix without a GUI.
+ *
+ */ 
+
+#ifndef _SPLAY_GLOBALS_H
+#define _SPLAY_GLOBALS_H
+
+#include "dllacces.h"
+#include "dllpath.h"
+#include "hxengin.h"
+#include "hxplayvelocity.h"
+#include "hxcore.h"
+#include "ihxmedpltfm.h"
+#include "excontxt.h"
+#include "preflist.h"
+
+#define HX_COMMAND_BUFFER_SIZE 256
+#define HX_MAX_NUM_MULTI_SEEKS 10
+struct _stGlobals
+{
+    _stGlobals()
+        : g_pDLLAccess(NULL),
+	  g_nPlayers(0),
+	  m_fpHXMediaPlatformOpen(NULL),
+	  m_fpHXCreateMediaPlatform(NULL),
+	  m_fpHXMediaPlatformClose(NULL),
+	  m_fpCreateEngine(NULL),
+	  m_fpCloseEngine(NULL),
+	  m_fpSetDLLAccessPath(NULL),
+	  bEnableAdviceSink(FALSE),
+          bEnableVerboseMode(FALSE),
+          g_bEnableSlowStart(TRUE),
+          g_bOnBeginOccurred(FALSE),
+          g_pszUsername( NULL),
+          g_pszPassword(NULL),
+          g_pszGUIDFile(NULL),
+          g_pszGUIDList(NULL),
+          g_Error(HXR_OK),
+	  g_ulNumSecondsPlayed(0),
+	  pMediaPlatform(NULL),
+          g_pIHXKicker(NULL),
+          bUseLegacyAPIs(FALSE),
+	  pEngine(NULL),
+          g_pQuickSeek(NULL),
+          g_bNullRender(FALSE),
+          g_bUserStop(FALSE),
+          g_bInitVelocity(FALSE),
+          g_bABD(FALSE),
+          g_pVelocityCaps(NULL),
+          g_ulNumMultiSeeks(0),
+          g_ulMultiSeekIndex(0),
+          g_bMultiSeek(FALSE),
+    	  g_uThreadIDForKicker(-1)
+    {
+        memset(g_szCommandBuffer, 0, HX_COMMAND_BUFFER_SIZE);
+        memset(g_szPriorCommandBuffer, 0, HX_COMMAND_BUFFER_SIZE);
+        memset(g_Players, 0, sizeof(g_Players));
+        memset(g_pszURLs, 0, sizeof(g_pszURLs));
+        memset(g_pClientContexts, 0, sizeof(g_pClientContexts));
+    }
+
+    #define MAX_NUM_PLAYERS     256
+    IHXPlayer*              g_Players[MAX_NUM_PLAYERS];
+    char                    *g_pszURLs[MAX_NUM_PLAYERS];
+    ExampleClientContext    *g_pClientContexts[MAX_NUM_PLAYERS];
+    int                      g_nPlayers;
+    DLLAccessPath            g_statclnt;
+    DLLAccess*              g_pDLLAccess;
+    CHXPrefList             g_prefList;
+
+    FPHXMEDIAPLATFORMOPEN    m_fpHXMediaPlatformOpen;
+    FPHXCREATEMEDIAPLATFORM  m_fpHXCreateMediaPlatform;
+    FPHXMEDIAPLATFORMCLOSE   m_fpHXMediaPlatformClose;
+
+    FPRMCREATEENGINE         m_fpCreateEngine;
+    FPRMCLOSEENGINE          m_fpCloseEngine;
+    FPRMSETDLLACCESSPATH     m_fpSetDLLAccessPath;
+
+    HXBOOL                   bEnableAdviceSink;
+    HXBOOL                   bEnableVerboseMode;
+    HXBOOL                   g_bEnableSlowStart;
+    HXBOOL                   g_bOnBeginOccurred;
+    char*                    g_pszUsername;
+    char*                    g_pszPassword;
+    char*                    g_pszGUIDFile;
+    char*                    g_pszGUIDList;
+    HX_RESULT                g_Error;
+    UINT32                   g_ulNumSecondsPlayed;
+    IHXMediaPlatform*	     pMediaPlatform;
+    IHXMediaPlatformKicker*  g_pIHXKicker;
+    UINT32	             g_uThreadIDForKicker;
+    pthread_t	             g_pThreadKickmanId;
+    HXBOOL                   bUseLegacyAPIs;
+    IHXClientEngine*         pEngine;
+    IHXQuickSeek*            g_pQuickSeek;
+    HXBOOL                   g_bNullRender;
+    HXBOOL                   g_bUserStop;
+    HXBOOL                   g_bInitVelocity;
+    HXBOOL                   g_bABD;
+    IHXPlaybackVelocityCaps* g_pVelocityCaps;
+    HXBOOL                   g_bMultiSeek;
+    UINT32                   g_ulMultiSeekTime[HX_MAX_NUM_MULTI_SEEKS];
+    UINT32                   g_ulNumMultiSeeks;
+    UINT32                   g_ulMultiSeekIndex;
+    char                     g_szCommandBuffer[HX_COMMAND_BUFFER_SIZE];
+    char                     g_szPriorCommandBuffer[HX_COMMAND_BUFFER_SIZE];
+};
+
+
+#endif // _SPLAY_GLOBALS_H
Index: helix-libs/clientapps/clutter/iids.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/iids.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,50 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+// define all guids here once...
+#define INITGUID
+#define NCIHACK
+#include "hxtypes.h"
+#include "hxcom.h"
+#include "hxiids.h"
+#include "hxpiids.h"
+#if defined _WINDOWS
+#if defined (HELIX_FEATURE_DIRECT_SOUND)
+#include "dsound.h"
+#endif /* HELIX_FEATURE_DIRECT_SOUND */
+#if defined (HELIX_FEATURE_VIDEO) && !defined(_WINCE)
+#include "ddraw.h"
+#endif /* HELIX_FEATURE_VIDEO */
+#endif
Index: helix-libs/clientapps/clutter/linux2.pcf
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/linux2.pcf	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,42 @@
+# 
+# ***** BEGIN LICENSE BLOCK ***** 
+# Version: RCSL 1.0/RPSL 1.0 
+#  
+# Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+#      
+# The contents of this file, and the files included with this file, are 
+# subject to the current version of the RealNetworks Public Source License 
+# Version 1.0 (the "RPSL") available at 
+# http://www.helixcommunity.org/content/rpsl unless you have licensed 
+# the file under the RealNetworks Community Source License Version 1.0 
+# (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+# in which case the RCSL will apply. You may also obtain the license terms 
+# directly from RealNetworks.  You may not use this file except in 
+# compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+# applicable to this file, the RCSL.  Please see the applicable RPSL or 
+# RCSL for the rights, obligations and limitations governing use of the 
+# contents of the file.  
+#  
+# This file is part of the Helix DNA Technology. RealNetworks is the 
+# developer of the Original Code and owns the copyrights in the portions 
+# it created. 
+#  
+# This file, and the files included with this file, is distributed and made 
+# available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+# EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+# INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+# FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+# 
+# Technology Compatibility Kit Test Suite(s) Location: 
+#    http://www.helixcommunity.org/content/tck 
+# 
+# Contributor(s): 
+#  
+# ***** END LICENSE BLOCK ***** 
+# 
+
+project.AddSystemLibraries("dl", "m", "pthread")
+
+if (project.IsDefined("HELIX_FEATURE_VIDEO") and
+    project.IsDefined("USE_XWINDOWS")):
+	project.AddSystemLibraries("X11")
Index: helix-libs/clientapps/clutter/player.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/player.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,1057 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: RCSL 1.0/RPSL 1.0
+ *
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved.
+ *
+ * The contents of this file, and the files included with this file, are
+ * subject to the current version of the RealNetworks Public Source License
+ * Version 1.0 (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the RealNetworks Community Source License Version 1.0
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl,
+ * in which case the RCSL will apply. You may also obtain the license terms
+ * directly from RealNetworks.  You may not use this file except in
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or
+ * RCSL for the rights, obligations and limitations governing use of the
+ * contents of the file.
+ *
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the portions
+ * it created.
+ *
+ * This file, and the files included with this file, is distributed and made
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ *
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ *
+ * Contributor(s):
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/****************************************************************************
+ *
+ *  Test Client:
+ *
+ *
+ *  This is an test client running on Windows, Mac, and Unix without a GUI.
+ *
+ */
+#include "hxtypes.h"
+
+#include <stdlib.h>
+
+#include "hlxclib/time.h"
+#include "ihxmedpltfm.h"
+#include "hxwintyp.h"
+#include "hxcom.h"
+#include "ihxpckts.h"
+#include "hxcomm.h"
+#include "hxmon.h"
+#include "hxfiles.h"
+#include "hxengin.h"
+#include "hxcore.h"
+#include "hxclsnk.h"
+#include "hxgroup.h"
+#include "hxerror.h"
+#include "hxauth.h"
+#include "hxwin.h"
+#include "hxprefs.h"
+#include "hxtbuf.h"
+#include "fivemmap.h"
+#include "dllacces.h"
+#include "hxausvc.h"
+#include "hxstrutl.h"
+#include "hxgroup.h"
+#include "hxwin.h"
+#include "hxtick.h"
+#include "hxbuffer.h"
+#include "hxplayvelocity.h"
+#include "pckunpck.h"  //  For CreateAndSetBufferCCF()
+#include "hxvctrl.h"
+#include "hxbsrc.h"
+#include "excallback.h"
+#include "pthread.h"
+
+#if defined(HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION)
+#include "hxpfs.h"
+#endif //  HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION.
+
+#if defined(HELIX_FEATURE_PREFERENCES)
+#include "preflist.h"
+#endif /* #if defined(HELIX_FEATURE_PREFERENCES) */
+#include "exadvsnk.h"
+#include "exerror.h"
+#include "exsitsup.h"
+#include "exaumgr.h"
+#if defined(_WIN32)
+#include "exabd.h"
+#endif
+#include "excontxt.h"
+#include "print.h"
+#if defined(USE_XWINDOWS)
+#include <X11/Xlib.h>
+#endif
+#if defined (_UNIX)
+#include <stdio.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <termios.h>
+#endif
+#if defined(_WINDOWS)
+#include <conio.h>
+#endif
+
+#ifdef __TCS__
+#include <unistd.h>
+#if defined(__cplusplus)
+extern      "C"     {
+#endif      /* defined(__cplusplus) */
+    extern      unsigned long  tmosTimSleep(unsigned long ticks);
+    unsigned long       gForcePlayerToStop = 0;
+#if defined(__cplusplus)
+}
+#endif      /* defined(__cplusplus) */
+#endif
+
+#if defined (_MACINTOSH) || defined (_MAC_UNIX)
+bool gMacPlayerIsDone = false;
+#endif
+
+
+#if defined _VXWORKS
+#include "sys/times.h"
+#include "string.h"
+#include "hxtime.h"
+#endif
+
+#if defined(_MACINTOSH)
+#ifndef _MAC_MACHO
+#include <sioux.h>
+#include <console.h>
+#endif
+#endif
+
+#include "dllpath.h"
+
+#ifdef _SYMBIAN
+#include <e32svr.h>
+#include "platform/symbian/symbian_event_hndlr.h"
+#endif
+
+ENABLE_DLLACCESS_PATHS(g_SPlayAccessPath);
+
+// typedef for SetDLLAccessPath
+
+
+#include "thrdutil.h"
+
+#if defined(_AIX)
+#include <strings.h>
+#endif
+
+#if defined _DEBUG || defined DEBUG
+#include "debug.h"
+#endif
+
+#ifndef MAX_PATH
+#define MAX_PATH    256
+#endif //!MAX_PATH
+
+#if defined(HELIX_CONFIG_NOSTATICS)
+# include "globals/hxglobals.h"
+#endif
+
+#define MAX_NUM_URLS 10
+
+#include "globals.h" //for global struct.
+
+#include "player.h"
+
+#if defined(_WINDOWS) && defined(_STATICALLY_LINKED)
+HINSTANCE g_hInstance = NULL;
+#endif
+
+struct _stGlobals*& GetGlobal()
+{
+#if defined(HELIX_CONFIG_NOSTATICS)
+    static const struct _stGlobals* const _g_pstGlobals = NULL;
+    struct _stGlobals*& g_pstGlobals = (struct _stGlobals*&)HXGlobalPtr::Get(&_g_pstGlobals);
+#else
+    static struct _stGlobals* g_pstGlobals = NULL;
+#endif
+    if( g_pstGlobals == NULL )
+    {
+        g_pstGlobals = new struct _stGlobals();
+    }
+    return g_pstGlobals;
+
+}
+
+
+// Constants
+const int DEFAULT_TIME_DELTA = 2000;
+const int DEFAULT_STOP_TIME  = -1;
+const int SLEEP_TIME         = 5;
+const int GUID_LEN           = 64;
+
+// Function prototypes
+void  PrintUsage(const char* pszAppName);
+HXBOOL  AllPlayersDone(int nNumPlayers, IHXPlayer** ppPlayers);
+void  StopAllPlayers(int nNumPlayers, IHXPlayer** ppPlayers);
+HXBOOL  ReadGUIDFile();
+char* GetAppName(char* pszArgv0);
+
+#ifdef __TCS__
+#if defined(__cplusplus)
+extern      "C"     {
+#endif      /* defined(__cplusplus) */
+
+    extern      void    _alloc_stats(int verbose);
+#if defined(__cplusplus)
+}
+#endif      /* defined(__cplusplus) */
+
+static  IHXPlayer** g_Players;
+static  int         g_nPlayers = 0;
+static  long        evtCount = 0;
+static  long        evtFullCount = 0;
+#endif
+
+
+
+#if defined(HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION)
+HX_RESULT
+DumpPFdata(IHXPresentationFeatureManager* pPFMgr,
+           const char* pszPFName)
+{
+    HX_RESULT hxr = HXR_OK;
+
+    IHXBuffer* pFeatureCurrentSetting = NULL;
+    IHXValues* pFeatureOptions = NULL;
+
+    if (!pPFMgr  ||  !pszPFName)
+    {
+        hxr = HXR_INVALID_PARAMETER;
+    }
+    else
+    {
+        //  List all the options for this PF:
+        HX_RESULT hxr = pPFMgr->GetPresentationFeature(
+                pszPFName,
+                pFeatureCurrentSetting,
+                pFeatureOptions);
+
+        if (FAILED(hxr))
+        {
+            //  PF doesn't exist!
+            STDOUT("\t%s - No such presentation feature\n\n", pszPFName);
+        }
+        else
+        {
+            //  Now, go through pFeatureOptions and display
+            // them and their "is-selectable"-flag values:
+            const char* pszPFOptionName = NULL;
+            const char* pszPFCurSetting = pFeatureCurrentSetting?
+                    (const char*)pFeatureCurrentSetting->GetBuffer() : NULL;
+            UINT32 bPFOptionIsSelectableFlag = FALSE;
+            IHXBuffer* pPFOptionIsSelectableFlag = NULL;
+
+            HX_ASSERT(pszPFCurSetting);
+            STDOUT("\t%s\t(Current setting == \"%s\")\n", pszPFName, pszPFCurSetting?
+                    pszPFCurSetting : "<ERROR: THIS PF HAS NO CURRENT SETTING!>");
+            
+            if (!pFeatureOptions) //  NULL is OK; that means freeform (open-ended):
+            {
+                STDOUT("\t\t(%s's options are freeform, i.e., open-ended)\n",
+                        pszPFName);
+            }
+            else //  List all the options and their flags:
+            {
+                if (HXR_OK == pFeatureOptions->GetFirstPropertyCString(pszPFOptionName,
+                        pPFOptionIsSelectableFlag)  &&  *pszPFOptionName)
+                {
+                    do
+                    {
+                        const UCHAR* pIsSelFlag = pPFOptionIsSelectableFlag->GetBuffer();
+                        if (pIsSelFlag  &&  *pIsSelFlag)
+                        {
+                            //  Anything but '0' (zero) is treated as '1' (is selectable):
+                            bPFOptionIsSelectableFlag = (HXBOOL)('0' != *pIsSelFlag  &&
+                                    '\0' == *(pIsSelFlag+1));
+                        }
+                        else
+                        {
+                            //  Set the error, but we'll go ahead and treat it as '0':
+                            hxr = HXR_INVALID_PARAMETER;
+                            bPFOptionIsSelectableFlag = FALSE;
+                        }
+
+                        STDOUT("\t\t%s\t\tIs selectable: %s\n",
+                                pszPFOptionName, bPFOptionIsSelectableFlag? "yes":"no");
+                        //  Release it to get the next PF:
+                        HX_RELEASE(pPFOptionIsSelectableFlag);
+                    } while (HXR_OK == pFeatureOptions->GetNextPropertyCString(
+                                    pszPFOptionName, pPFOptionIsSelectableFlag));
+                }
+            }
+
+            HX_RELEASE(pPFOptionIsSelectableFlag);
+        }
+    }
+
+    HX_RELEASE(pFeatureCurrentSetting);
+    HX_RELEASE(pFeatureOptions);
+
+    return hxr;
+}
+#endif //  HELIX_FEATURE_PRESENTATION_FEATURE_SELECTION.
+
+
+char* RemoveWrappingQuotes(char* str)
+{
+    int len = strlen(str);
+    if (len > 0)
+    {
+        if (str[len-1] == '"') str[--len] = 0;
+        if (str[0] == '"') { int i = 0; do { str[i++] = str[i+1]; } while(--len); }
+    }
+    return str;
+}
+
+void *kickman(void *dummy)
+{
+	while(1) {
+		UINT32 sleepTime = 0;
+		IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker;
+		if( pKicker )
+		{
+			pKicker->Kick(GetGlobal()->g_uThreadIDForKicker, &sleepTime);
+		}
+		usleep(sleepTime);
+	}
+}
+
+PLAYER_API int init_main( )
+{
+#if defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC)
+    setvbuf(stdout, NULL, _IONBF, 0);
+#endif /* defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC) */
+
+    FPHXMEDIAPLATFORMOPEN   fpHXMediaPlatformOpen   = NULL;
+    FPHXCREATEMEDIAPLATFORM fpHXCreateMediaPlatform = NULL;
+    FPHXMEDIAPLATFORMCLOSE  fpHXMediaPlatformClose  = NULL;
+
+    FPRMCREATEENGINE        fpCreateEngine          = NULL;
+    FPRMCLOSEENGINE         fpCloseEngine           = NULL;
+    FPRMSETDLLACCESSPATH    fpSetDll                = NULL;
+
+    HX_RESULT               theErr                  = HXR_OK;
+    ExampleClientContext**  ppExContexts            = NULL;
+#if defined(HELIX_FEATURE_AUTO_BANDWIDTH_DETECTION) && defined(_WIN32)
+    ExampleABD*             pABD                    = NULL;
+#endif
+    IHXPlayer**             ppPlayers               = NULL;
+    IHXQuickSeek*           ppQuickSeek             = NULL;
+    IHXErrorSink*           pErrorSink              = NULL;
+    IHXErrorSinkControl*    pErrorSinkControl       = NULL;
+    UINT32                  ulABDResult             = 0;
+    UINT32                  ulProbPktSize           = 0;
+    UINT32                  ulProbPktNum            = 0;
+#if defined(HELIX_FEATURE_PLAYBACK_VELOCITY)
+    INT32                   lVelocity               = 100;
+    INT32                   lKeyFrameMode           = 0;
+    INT32                   lAutoSwitch             = 0;
+#endif /* #if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) */
+    CHXString*              pABDServer              = NULL;
+    char*                   pszURL[MAX_NUM_URLS];
+    char*                   pszURLOrig[MAX_NUM_URLS];
+    UINT32                  ulNumURLsFound          = 0;
+    int                     nNumPlayers             = 1;
+    int                     nNumPlayRepeats         = 1;
+    int                     nTimeDelta              = DEFAULT_TIME_DELTA;
+    int                     nStopTime               = DEFAULT_STOP_TIME;
+    bool                    bStopTime               = true;
+    int                     i                       = 0;
+    char*                   pszGUIDList             = NULL;
+#ifdef _MACINTOSH
+    char                    dllhome[MAX_PATH]       = {'\0'}; /* Flawfinder: ignore */
+#elif defined(_SYMBIAN)
+    char                    dllhome[MAX_PATH]       = "c:"; /* Flawfinder: ignore */
+#else
+    char                    dllhome[MAX_PATH]       = {'.','\0'}; /* Flawfinder: ignore */
+#endif
+    DLLAccess*              pDLLAccess              = NULL;
+    char                    staticLibPath[MAX_PATH] = {0}; /* Flawfinder: ignore */
+#ifdef _WINDOWS
+    HINSTANCE               hDll                    = NULL;
+#endif
+    bool                    bStopping = false;
+    int                     nPlay = 0;
+
+    // NULL out the URL arrays
+    memset(pszURL, 0, MAX_NUM_URLS * sizeof(char*));
+    memset(pszURLOrig, 0, MAX_NUM_URLS * sizeof(char*));
+
+
+    //See if the user has set their HELIX_LIBS env var. This is overridden by the
+    //-l option.
+    const char* pszHelixLibs = getenv("HELIX_LIBS");
+    if( pszHelixLibs )
+        SafeStrCpy( dllhome,  pszHelixLibs, MAX_PATH);
+
+
+
+    GetGlobal()->bEnableAdviceSink = TRUE;
+    GetGlobal()->g_prefList.Add("UseOverlay", "0");
+
+    SafeSprintf(staticLibPath, MAX_PATH, "%s/%s", dllhome, "hxmedpltfm.so");
+
+	if (dllhome)
+    {
+        GetDLLAccessPath()->SetPath(DLLTYPE_COMMON, dllhome);
+        GetDLLAccessPath()->SetPath(DLLTYPE_PLUGIN, dllhome);
+        GetDLLAccessPath()->SetPath(DLLTYPE_CODEC, dllhome);
+    }
+
+    // initialize the globals
+    GetGlobal()->m_fpCreateEngine    = NULL;
+    GetGlobal()->m_fpCloseEngine = NULL;
+    GetGlobal()->g_nPlayers = 0;
+
+  // prepare/load the HXCore module
+    pDLLAccess = new DLLAccess();
+
+    STDOUT("Simpleplayer is looking for the client core at %s\n", staticLibPath );
+
+    if (DLLAccess::DLL_OK != pDLLAccess->open(staticLibPath))
+    {
+        const char* pErrorString = NULL;
+        pErrorString = pDLLAccess->getErrorString();
+        STDERR("splayer: %s\n\n", pErrorString);
+#ifndef _STATICALLY_LINKED
+#ifndef _MACINTOSH
+        //Make sure the user has told us where to find the DLLs at. Either
+        //with the -l option or with the HELIX_LIBS env var.
+        STDERR("You must tell the player where to find the client core and\n");
+        STDERR("all of its supporting DLLs and codecs. Please use the -l\n");
+        STDERR("option or set your HELIX_LIBS env variable to point the player.\n");
+        STDERR("to where you have all of the DLLs installed.\n\n" );
+        //PrintUsage(argv[0]);
+#endif
+#endif
+        goto cleanup;
+    }
+
+    GetGlobal()->m_fpHXMediaPlatformOpen = (FPHXMEDIAPLATFORMOPEN) pDLLAccess->getSymbol("HXMediaPlatformOpen");
+    GetGlobal()->m_fpHXCreateMediaPlatform = (FPHXCREATEMEDIAPLATFORM) pDLLAccess->getSymbol("HXCreateMediaPlatform");
+    GetGlobal()->m_fpHXMediaPlatformClose = (FPHXMEDIAPLATFORMCLOSE) pDLLAccess->getSymbol("HXMediaPlatformClose");
+
+    GetGlobal()->m_fpCreateEngine = (FPRMCREATEENGINE) pDLLAccess->getSymbol("CreateEngine");
+    GetGlobal()->m_fpCloseEngine  = (FPRMCLOSEENGINE)  pDLLAccess->getSymbol("CloseEngine");
+    GetGlobal()->m_fpSetDLLAccessPath = (FPRMSETDLLACCESSPATH) pDLLAccess->getSymbol("SetDLLAccessPath");
+
+    if (GetGlobal()->m_fpHXMediaPlatformOpen == NULL    ||
+        GetGlobal()->m_fpHXCreateMediaPlatform == NULL  ||
+        GetGlobal()->m_fpHXMediaPlatformClose == NULL   ||
+        GetGlobal()->m_fpCreateEngine == NULL           ||
+        GetGlobal()->m_fpCloseEngine  == NULL           ||
+        GetGlobal()->m_fpSetDLLAccessPath == NULL )
+    {
+        theErr = HXR_FAILED;
+        goto cleanup;
+    }
+
+#if defined(USE_XWINDOWS) && defined(HELIX_FEATURE_VIDEO)
+    XInitThreads();
+#endif
+    
+    {
+        fpHXMediaPlatformOpen = GetGlobal()->m_fpHXMediaPlatformOpen;
+        fpHXCreateMediaPlatform = GetGlobal()->m_fpHXCreateMediaPlatform;
+        fpHXMediaPlatformClose = GetGlobal()->m_fpHXMediaPlatformClose;
+
+        if (HXR_OK != fpHXMediaPlatformOpen())
+        {
+            theErr = HXR_FAILED;
+            goto cleanup;
+        }
+
+        if (HXR_OK != fpHXCreateMediaPlatform((IHXMediaPlatform**)&GetGlobal()->pMediaPlatform))
+        {
+            theErr = HXR_FAILED;
+            goto cleanup;
+        }
+
+        IHXMediaPlatform* pMediaPlatform = GetGlobal()->pMediaPlatform;
+        
+
+        if (HXR_OK != pMediaPlatform->AddPluginPath("HelixSimplePlayer", dllhome))
+        {
+            theErr = HXR_FAILED;
+            goto cleanup;
+        }
+
+        if (HXR_OK != pMediaPlatform->Init(NULL))
+        {
+            theErr = HXR_FAILED;
+            goto cleanup;
+        }
+    
+        IHXCommonClassFactory* pCCF = NULL;
+        if (HXR_OK != pMediaPlatform->QueryInterface(IID_IHXCommonClassFactory,
+                                                     (void**)&pCCF))
+        {
+            theErr = HXR_FAILED;
+            goto cleanup;
+        }
+
+       if (HXR_OK != pCCF->CreateInstance(CLSID_IHXClientEngine, (void**)&GetGlobal()->pEngine))
+        {
+            HX_RELEASE(pCCF);
+            theErr = HXR_FAILED;
+            goto cleanup;
+        }
+
+        HX_RELEASE(pCCF);
+
+        IHXMediaPlatformKicker* pKicker = NULL;
+        pMediaPlatform->QueryInterface(IID_IHXMediaPlatformKicker, (void**)&pKicker);
+        HX_ASSERT(pKicker);
+        GetGlobal()->g_pIHXKicker = pKicker;
+	GetGlobal()->g_uThreadIDForKicker = HXGetCurrentThreadID();
+
+	pthread_t thread_id;
+	pthread_create(&thread_id, NULL, kickman, NULL);
+	GetGlobal()->g_pThreadKickmanId = thread_id;
+    }
+
+
+
+    {
+
+
+#if defined(_WIN32) && !defined(WIN32_PLATFORM_PSPC)
+        SetConsoleCtrlHandler((PHANDLER_ROUTINE)HandlerRoutine,
+                              TRUE);
+#endif
+
+    }
+
+    return HXR_OK;
+
+  cleanup:
+    deinit_main();
+    return HXR_FAIL;
+}
+
+/* Get the least index to available entry in Getglobal()->gPlayers */
+static int get_index()
+{
+    int i;
+    /* an simple implementation */
+    for (i = 0; i < MAX_NUM_PLAYERS; i++)
+    {
+        if (GetGlobal()->g_Players[i] == NULL) 
+            return i;
+    }
+
+    return -1;
+}
+
+PLAYER_API unsigned int get_curr_playtime(void *pPlayerHandle)
+{
+    unsigned int time = 0;
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    if (pPlayer)
+        time = pPlayer->GetCurrentPlayTime();
+    return time;
+}
+
+PLAYER_API int get_player(void **ppPlayerHandle, on_buffering_cb_t on_buffering_cb, on_pos_length_cb_t on_pos_length_cb, on_state_change_cb_t on_state_change_cb, on_new_frame_cb_t on_new_frame_cb, void *context)
+{
+    int index = get_index();
+    IHXPlayer **ppPlayer = (IHXPlayer **)ppPlayerHandle;
+    ExampleClientContext*  pExContext       = NULL;
+    pExContext = new ExampleClientContext(index);
+    if (!pExContext)
+    {
+        return HXR_UNEXPECTED;
+    }
+    pExContext->AddRef();
+
+    ppPlayer[0] = NULL;
+    IHXClientEngine* pEngine = GetGlobal()->pEngine;
+    if (HXR_OK != pEngine->CreatePlayer(*ppPlayer))
+    {
+        HX_RELEASE(pExContext);
+        return HXR_FAILED;
+    }
+#if 1
+    char*                   pszGUIDList             = NULL;
+    //initialize the example context
+    pszGUIDList = GetGlobal()->g_pszGUIDList;
+    {
+        char pszGUID[GUID_LEN + 1]; /* Flawfinder: ignore */ // add 1 for terminator
+        char* token = NULL;
+        IHXPreferences* pPreferences = NULL;
+
+        pszGUID[0] = '\0';
+
+        if (pszGUIDList)
+        {
+            // Get next GUID from the GUID list
+            {
+                token = strtok(pszGUIDList, "\n\0");
+            }
+            if (token)
+            {
+                strncpy(pszGUID, token, GUID_LEN); /* Flawfinder: ignore */
+                pszGUID[GUID_LEN] = '\0';
+            }
+        }
+
+        ppPlayer[0]->QueryInterface(IID_IHXPreferences,
+                                     (void**) &pPreferences);
+        
+        pExContext->Init(ppPlayer[0], pPreferences, pszGUID, on_buffering_cb, on_pos_length_cb, on_state_change_cb, on_new_frame_cb, context);
+
+        ppPlayer[0]->SetClientContext(pExContext);
+
+        HX_RELEASE(pPreferences);
+
+        IHXErrorSinkControl*    pErrorSinkControl       = NULL;
+        ppPlayer[0]->QueryInterface(IID_IHXErrorSinkControl,
+                                     (void**) &pErrorSinkControl);
+    
+        if (pErrorSinkControl)
+        {
+            IHXErrorSink*           pErrorSink              = NULL;
+            pExContext->QueryInterface(IID_IHXErrorSink,
+                    (void**) &pErrorSink);
+            if (pErrorSink)
+            {
+                pErrorSinkControl->AddErrorSink(pErrorSink, HXLOG_EMERG, HXLOG_INFO);
+            }
+            HX_RELEASE(pErrorSink);
+        }
+        HX_RELEASE(pErrorSinkControl);
+	GetGlobal()->g_prefList.SetPreferences(ppPlayer[0]);
+
+    }
+#endif
+    HX_ASSERT(GetGlobal()->g_nPlayers < MAX_NUM_PLAYERS);
+    GetGlobal()->g_Players[index] = ppPlayer[0];
+    GetGlobal()->g_pClientContexts[index] = pExContext;
+    GetGlobal()->g_nPlayers++;
+
+    return HXR_OK;
+}
+
+static int get_index_by_player( IHXPlayer *pPlayer)
+{
+    int i;
+    /* an simple implementation */
+    for (i = 0; i < MAX_NUM_PLAYERS; i++)
+    {
+       if (GetGlobal()->g_Players[i] && GetGlobal()->g_Players[i] == pPlayer)
+           return i;
+    }
+
+    return -1;
+}
+
+PLAYER_API int player_openurl( void *pPlayerHandle, char *pszRawURL)
+{
+    HX_RESULT ret;
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    int index = get_index_by_player(pPlayer);
+    if (index < 0)
+        return HXR_FAIL;
+    
+    char *pszURLOrig = RemoveWrappingQuotes(pszRawURL);
+
+    //if no "://" was found lets add file:// by default so that you
+    //can refer to local content as just ./splay ~/Content/startrek.rm,
+    //for example, and not ./splay file:///home/gregory/Content/startrek.rm
+    char* pszAddOn = NULL;
+    if( strstr( pszURLOrig, "://") )
+        pszAddOn = (char *)"";
+    else
+        pszAddOn = (char *)"file://";
+
+    char *pszURL = new char[strlen(pszURLOrig)+strlen(pszAddOn)+1];
+    sprintf( pszURL, "%s%s", pszAddOn, pszURLOrig ); /* Flawfinder: ignore */
+    // Increment the number of URLs we have found
+    STDERR("opening %s on player\n", pszURL);
+
+    GetGlobal()->g_pszURLs[index] = pszURL;
+    ret = pPlayer->OpenURL(pszURL);
+ 
+    UINT32 sleepTime = 0;
+
+    IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker;
+    if( pKicker )
+    {
+        pKicker->Kick(HXGetCurrentThreadID(), &sleepTime);
+    }
+
+    return ret;
+}
+
+PLAYER_API int put_player( void *pPlayerHandle)
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    int index;
+    index = get_index_by_player(pPlayer);
+    if (index < 0)
+        return HXR_FAIL;
+
+    ExampleClientContext *pClientContext = GetGlobal()->g_pClientContexts[index];
+    if (pClientContext) {
+        pClientContext->Release();
+        pClientContext = NULL;
+    }
+
+    GetGlobal()->g_pClientContexts[index] = NULL;
+    if (pPlayer) {
+        if (GetGlobal()->pEngine) {
+            GetGlobal()->pEngine->ClosePlayer(pPlayer);
+        }
+        pPlayer->Release();
+        pPlayer = NULL;
+    }
+    GetGlobal()->g_Players[index] = NULL;
+    GetGlobal()->g_nPlayers--;
+    delete [] GetGlobal()->g_pszURLs[index];
+    GetGlobal()->g_pszURLs[index] = NULL;
+
+    return HXR_OK;
+}
+
+PLAYER_API int player_geturl( void *pPlayerHandle, char **pszURL)
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    int index = get_index_by_player(pPlayer);
+    if (index >= 0) {
+        *pszURL = GetGlobal()->g_pszURLs[index];
+        return HXR_OK;
+    }
+
+    return  HXR_FAIL;
+}
+
+PLAYER_API int player_begin( void *pPlayerHandle )
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    UINT32 sleepTime = 0;
+    pPlayer->Begin();
+
+#if 0
+    IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker;
+	    if( pKicker )
+	    {
+		    pKicker->Kick(HXGetCurrentThreadID(), &sleepTime);
+	    }
+#endif
+    return HXR_OK;
+}
+
+PLAYER_API int player_pause( void *pPlayerHandle )
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    UINT32 sleepTime = 0;
+    pPlayer->Pause();
+
+#if 0
+    IHXMediaPlatformKicker* pKicker = GetGlobal()->g_pIHXKicker;
+	    if( pKicker )
+	    {
+		    pKicker->Kick(HXGetCurrentThreadID(), &sleepTime);
+	    }
+#endif
+    return HXR_OK;
+}
+
+PLAYER_API int player_stop( void *pPlayerHandle )
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    pPlayer->Stop();
+    return HXR_OK;
+}
+
+#if 0
+int main(int argc, char *argv[])
+{
+    IHXPlayer *pPlayer;
+    init_main();
+    while(1) {
+        get_player(&pPlayer);
+        player_openurl(pPlayer, argv[1]);
+        player_begin(pPlayer);
+     //   sleep(2);
+        player_stop(pPlayer);
+        put_player(pPlayer);
+    }
+    deinit_main();
+    return 0;
+}
+#endif
+
+PLAYER_API int player_seek(void *pPlayerHandle, int pos)
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    if (pPlayer == NULL)
+        return HXR_FAIL;
+
+    return pPlayer->Seek(pos);
+}
+PLAYER_API int player_getvolume(void *pPlayerHandle)
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    if (pPlayer == NULL)
+        return HXR_FAIL;
+
+    int volume = 0;
+
+    IHXAudioPlayer* pAudioPlayer = NULL;
+    pPlayer->QueryInterface(IID_IHXAudioPlayer, (void**) &pAudioPlayer);
+    if (pAudioPlayer)
+    {
+        // Get the IHXVolume
+        IHXVolume* pVolume = pAudioPlayer->GetAudioVolume();
+        if (pVolume)
+        {
+            volume = pVolume->GetVolume();
+        }
+        HX_RELEASE(pVolume);
+    }
+    HX_RELEASE(pAudioPlayer);
+
+    return volume;
+}
+
+
+PLAYER_API int player_setvolume(void *pPlayerHandle, unsigned short volume)
+{
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    if (pPlayer == NULL)
+        return HXR_FAIL;
+
+    IHXAudioPlayer* pAudioPlayer = NULL;
+    pPlayer->QueryInterface(IID_IHXAudioPlayer, (void**) &pAudioPlayer);
+    if (pAudioPlayer)
+    {
+        // Get the IHXVolume
+        IHXVolume* pVolume = pAudioPlayer->GetAudioVolume();
+        if (pVolume)
+        {
+            pVolume->SetVolume(volume);
+        }
+        HX_RELEASE(pVolume);
+    }
+    HX_RELEASE(pAudioPlayer);
+}
+
+PLAYER_API int deinit_main()
+{
+ 
+    pthread_cancel(GetGlobal()->g_pThreadKickmanId);
+    int ret ;
+    ret = pthread_join(GetGlobal()->g_pThreadKickmanId, NULL);
+    if (ret < 0) {
+	    perror("pthread_join error\n");
+    }
+#if defined(HELIX_FEATURE_PLAYBACK_VELOCITY)
+    if (GetGlobal()->g_pVelocityCaps)
+    {
+        IHXPlaybackVelocityCaps* pCaps = GetGlobal()->g_pVelocityCaps;
+        pCaps->Release();
+        GetGlobal()->g_pVelocityCaps = NULL;
+    }
+#endif /* #if defined(HELIX_FEATURE_PLAYBACK_VELOCITY) */
+
+#ifdef __TCS__
+    g_nPlayers = 0;
+#endif
+
+    
+    {
+        IHXClientEngine* pEngine = GetGlobal()->pEngine;
+
+        if (pEngine)
+        {
+            IHXClientEngine2* pEngine2 = NULL;
+            if (HXR_OK == pEngine->QueryInterface(IID_IHXClientEngine2, 
+                                                  (void**)&pEngine2))
+            {
+                pEngine2->Close();
+            }
+            HX_RELEASE(pEngine2);
+        }
+        HX_RELEASE(GetGlobal()->pEngine);
+        HX_RELEASE(GetGlobal()->g_pIHXKicker);
+        
+        if (GetGlobal()->pMediaPlatform)
+        {
+            // Reset() not only close the platform but also remove all
+            // persistent information(i.e. preferences) maintained by the
+            // platform
+            // GetGlobal()->pMediaPlatform->Reset(NULL);
+            GetGlobal()->pMediaPlatform->Close();
+            HX_RELEASE(GetGlobal()->pMediaPlatform);
+        }
+
+        if (GetGlobal()->m_fpHXMediaPlatformClose)
+        {
+            GetGlobal()->m_fpHXMediaPlatformClose();
+        }
+    }
+
+
+    if (GetGlobal()->bEnableVerboseMode)
+    {
+        STDOUT("\nDone.\n");
+    }
+
+    if (GetGlobal()->g_pszUsername)
+    {
+        delete [] GetGlobal()->g_pszUsername;
+        GetGlobal()->g_pszUsername = NULL;
+    }
+    if (GetGlobal()->g_pszPassword)
+    {
+        delete [] GetGlobal()->g_pszPassword;
+        GetGlobal()->g_pszPassword = NULL;
+    }
+    if (GetGlobal()->g_pszGUIDFile)
+    {
+        delete [] GetGlobal()->g_pszGUIDFile;
+        GetGlobal()->g_pszGUIDFile = NULL;
+    }
+    if (GetGlobal()->g_pszGUIDList)
+    {
+        delete [] GetGlobal()->g_pszGUIDList;
+        GetGlobal()->g_pszGUIDList = NULL;
+    }
+    // If an error occurred during playback, return that
+    
+    if (GetGlobal()->g_Error != HXR_OK)
+    {
+        return GetGlobal()->g_Error;
+    }
+    // or HXR_OK (if there was more than one player)
+    else
+    {
+        return HXR_OK;
+    }
+}
+char* GetAppName(char* pszArgv0)
+{
+    char* pszAppName;
+
+    pszAppName = strrchr(pszArgv0, '\\');
+
+    if (NULL == pszAppName)
+    {
+        return pszArgv0;
+    }
+    else
+    {
+        return pszAppName + 1;
+    }
+}
+
+void PrintUsage(const char* pszAppName)
+{
+}
+
+
+
+HXBOOL ReadGUIDFile()
+{
+    HXBOOL  bSuccess = FALSE;
+    FILE* pFile    = NULL;
+    int   nNumRead = 0;
+    int   readSize = 10000;
+    char*  pszBuffer = new char[readSize];
+
+    if (GetGlobal()->g_pszGUIDFile)
+    {
+        if((pFile = fopen(GetGlobal()->g_pszGUIDFile, "r")) != NULL)
+        {
+            // Read in the entire file
+            nNumRead = fread(pszBuffer, sizeof(char), readSize, pFile);
+            pszBuffer[nNumRead] = '\0';
+
+            // Store it for later parsing
+            GetGlobal()->g_pszGUIDList = new char[nNumRead + 1];
+            strcpy(GetGlobal()->g_pszGUIDList, pszBuffer); /* Flawfinder: ignore */
+
+            fclose(pFile);
+            pFile = NULL;
+
+            if (nNumRead > 0)
+            {
+                bSuccess = TRUE;
+            }
+        }
+    }
+
+    delete [] pszBuffer;
+
+    return bSuccess;
+}
+
+static int are_all_src_seekable(IHXPlayer *pPlayer)
+{
+    UINT16 nSrcCnt;
+    nSrcCnt = pPlayer->GetSourceCount();
+    HXSource *pSource = NULL;    /* This is brute-force */
+    for (UINT16 i = 0; i < nSrcCnt; i++) 
+    {
+        if (pPlayer->GetSource(i, (IUnknown *&)pSource) == HXR_OK)
+        {
+            if (!pSource->IsSeekable())
+                return FALSE;
+
+
+        }
+    }
+
+}
+
+PLAYER_API int player_canseek(void *pPlayerHandle)
+{
+    if (!pPlayerHandle)
+        return FALSE;
+
+    IHXPlayer *pPlayer = (IHXPlayer *)pPlayerHandle;
+    ExampleClientContext*  pExContext=NULL;
+    if (pPlayer->GetClientContext((IUnknown*&)pExContext) != HXR_OK)
+        return FALSE;
+
+    if (!pExContext)
+        return FALSE;
+
+    EHXClientState State = pExContext->GetState();
+
+    int all_src_seekable =  are_all_src_seekable(pPlayer);
+
+    HX_RELEASE(pExContext);
+
+    if (State < HX_CLIENT_STATE_CONNECTED)
+        return TRUE;
+
+    if (all_src_seekable && (!pPlayer->IsLive() || State == HX_CLIENT_STATE_PAUSED))
+        return TRUE;
+
+    return FALSE;
+}
+
+
Index: helix-libs/clientapps/clutter/player.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/player.h	2008-10-13 06:54:45.000000000 -0700
@@ -0,0 +1,60 @@
+#ifndef _PLAYER_H_
+#define _PLAYER_H_
+
+#ifdef __cplusplus
+#define PLAYER_API    extern "C"
+#else
+#define PLAYER_API
+#endif
+
+/* Duplicate of  EHXClientState */
+typedef enum _EPlayerStateState
+{
+    PLAYER_STATE_READY = 0,  // uninitialized
+    PLAYER_STATE_CONNECTING, // attempting to connect to sources
+    PLAYER_STATE_CONNECTED,  // connected to sources (realized)
+    PLAYER_STATE_OPENING,    // opening sources
+    PLAYER_STATE_OPENED,     // opened sources
+    PLAYER_STATE_PREFETCHING,// obtaining resources, buffering, etc.
+    PLAYER_STATE_PREFETCHED, // ready for playback at time zero
+    PLAYER_STATE_PLAYING,    // currently playing
+    PLAYER_STATE_PAUSED,     // paused
+    PLAYER_STATE_SEEKING     // seeking
+} EHXPlayerState;
+
+typedef struct {
+    int left;
+    int top;
+    int right;
+    int bottom;
+} PlayerRect;
+
+typedef struct {
+    PlayerRect Rect;
+    unsigned int  cx;
+    unsigned int cy;
+} PlayerImgInfo;
+
+typedef void (*on_pos_length_cb_t)(unsigned int, unsigned int, void *);
+typedef void (*on_buffering_cb_t)(unsigned int, unsigned short, void *);
+typedef void (*on_state_change_cb_t)(unsigned short, unsigned short, void *);
+typedef void (*on_new_frame_cb_t)(unsigned char *p, unsigned int size, PlayerImgInfo *rect, void *context);
+
+PLAYER_API int init_main();
+PLAYER_API int deinit_main();
+PLAYER_API int get_player(void **ppPlayerHandle, on_buffering_cb_t on_buffering_cb, on_pos_length_cb_t on_pos_length_cb, on_state_change_cb_t on_state_change_cb, on_new_frame_cb_t on_new_frame_cb, void *context);
+PLAYER_API int player_openurl( void *pPlayerHandle, char *pszRawURL);
+PLAYER_API int put_player( void *pPlayerHandle);
+PLAYER_API int player_geturl( void *pPlayerHandle, char **pszURL);
+PLAYER_API int player_begin( void *pPlayerHandle );
+PLAYER_API int player_stop( void *pPlayerHandle );
+PLAYER_API int player_pause( void *pPlayerHandle );
+PLAYER_API unsigned int get_curr_playtime(void *pPlayerHandle);
+PLAYER_API int player_seek(void *pPlayerHandle, int pos);
+PLAYER_API int player_getvolume(void *pPlayerHandle);
+PLAYER_API int player_setvolume(void *pPlayerHandle, unsigned short volumn);
+PLAYER_API int player_canseek(void *pPlayerHandle);
+
+
+#endif
+
Index: helix-libs/clientapps/clutter/preflist.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/preflist.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,142 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: preflist.cpp,v 1.2 2007/07/06 20:32:36 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+#include "preflist.h"
+
+#include "hxstring.h"
+#include "hxccf.h"
+#include "hxprefs.h"
+#include "ihxpckts.h"
+
+class CHXPrefInfo
+{
+public:
+    CHXPrefInfo(const char* pKey, const char* pValue);
+    ~CHXPrefInfo();
+    
+    const char* Key() const { return m_key;}
+    const char* Value() const { return m_value;}
+
+private:
+    CHXString m_key;
+    CHXString m_value;
+};
+
+CHXPrefInfo::CHXPrefInfo(const char* pKey, const char* pValue) :
+    m_key(pKey),
+    m_value(pValue)
+{}
+
+CHXPrefInfo::~CHXPrefInfo()
+{}
+
+CHXPrefList::CHXPrefList()
+{}
+
+CHXPrefList::~CHXPrefList()
+{
+    Clear();
+}
+
+void CHXPrefList::Add(const char* pKey, const char* pValue)
+{
+    CHXPrefInfo* pInfo = new CHXPrefInfo(pKey, pValue);
+
+    if (pInfo)
+    {
+        if (!m_prefInfo.AddTail(pInfo))
+        {
+            // We failed to insert the preference.
+            HX_DELETE(pInfo);
+        }
+    }
+}
+
+void CHXPrefList::Clear()
+{
+    while(!m_prefInfo.IsEmpty())
+    {
+        CHXPrefInfo* pInfo = (CHXPrefInfo*)m_prefInfo.RemoveHead();
+        HX_DELETE(pInfo);
+    }
+}
+
+void CHXPrefList::SetPreferences(IUnknown* pContext)
+{
+    IHXPreferences* pPrefs = NULL;
+    IHXCommonClassFactory* pCCF = NULL;
+
+    if (pContext &&
+        (HXR_OK == pContext->QueryInterface(IID_IHXPreferences,
+                                            (void**)&pPrefs)) &&
+        (HXR_OK == pContext->QueryInterface(IID_IHXCommonClassFactory,
+                                            (void**)&pCCF)))
+    {
+        CHXSimpleList::Iterator itr = m_prefInfo.Begin();
+        
+        for(; itr != m_prefInfo.End(); ++itr)
+        {
+            CHXPrefInfo* pInfo = (CHXPrefInfo*)(*itr);
+            
+            IHXBuffer* pBuf = NULL;
+            
+            if ((HXR_OK == pCCF->CreateInstance(CLSID_IHXBuffer,
+                                                (void**)&pBuf)) &&
+                (HXR_OK == pBuf->Set((const unsigned char*)pInfo->Value(),
+                                     strlen(pInfo->Value()))))
+            {
+                pPrefs->WritePref(pInfo->Key(), pBuf);
+            }
+
+            HX_RELEASE(pBuf);
+        }
+    }
+
+    HX_RELEASE(pPrefs);
+    HX_RELEASE(pCCF);
+}
Index: helix-libs/clientapps/clutter/preflist.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/preflist.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,69 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: preflist.h,v 1.2 2007/07/06 20:32:36 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+#ifndef PREFLIST_H
+#define PREFLIST_H
+
+#include "hxslist.h"
+
+class CHXPrefList
+{
+public:
+    CHXPrefList();
+    ~CHXPrefList();
+
+    void Add(const char* pKey, const char* pValue);
+    void Clear();
+
+    void SetPreferences(IUnknown* pContext);
+
+private:
+    CHXSimpleList m_prefInfo;
+};
+
+#endif /* PREFLIST_H */
Index: helix-libs/clientapps/clutter/print.cpp
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/print.cpp	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,80 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#include <stdarg.h>
+#include <stdio.h>
+#include "print.h"
+#ifdef WIN32_PLATFORM_PSPC
+#include "hlxosstr.h"
+#include <winbase.h>
+#endif
+
+int print2stdout(const char* pFmt, ...)
+{
+    va_list args;
+    
+    va_start(args, pFmt);
+
+#ifdef WIN32_PLATFORM_PSPC
+    char szMessage[512];
+    int ret = vsprintf(szMessage, pFmt, args);
+    OutputDebugString(OS_STRING(szMessage));
+#else
+    int ret = vfprintf(stdout, pFmt, args);
+#endif
+
+    va_end(args);
+
+    return ret;
+}
+
+int print2stderr(const char* pFmt, ...)
+{
+    va_list args;
+    
+    va_start(args, pFmt);
+
+#ifdef WIN32_PLATFORM_PSPC
+    char szMessage[512];
+    int ret = vsprintf(szMessage, pFmt, args);
+    OutputDebugString(OS_STRING(szMessage));
+#else
+    int ret = vfprintf(stderr, pFmt, args);
+#endif
+
+    va_end(args);
+
+    return ret;
+}
Index: helix-libs/clientapps/clutter/print.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/print.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,60 @@
+/* ***** BEGIN LICENSE BLOCK ***** 
+ * Version: RCSL 1.0/RPSL 1.0 
+ *  
+ * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+ *      
+ * The contents of this file, and the files included with this file, are 
+ * subject to the current version of the RealNetworks Public Source License 
+ * Version 1.0 (the "RPSL") available at 
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed 
+ * the file under the RealNetworks Community Source License Version 1.0 
+ * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+ * in which case the RCSL will apply. You may also obtain the license terms 
+ * directly from RealNetworks.  You may not use this file except in 
+ * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+ * applicable to this file, the RCSL.  Please see the applicable RPSL or 
+ * RCSL for the rights, obligations and limitations governing use of the 
+ * contents of the file.  
+ *  
+ * This file is part of the Helix DNA Technology. RealNetworks is the 
+ * developer of the Original Code and owns the copyrights in the portions 
+ * it created. 
+ *  
+ * This file, and the files included with this file, is distributed and made 
+ * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+ * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+ * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location: 
+ *    http://www.helixcommunity.org/content/tck 
+ * 
+ * Contributor(s): 
+ *  
+ * ***** END LICENSE BLOCK ***** */ 
+
+#ifndef PRINT_H
+#define PRINT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _SYMBIAN
+#include "platform/symbian/symbian_print.h"
+
+#define STDOUT symbianPrint
+#define STDERR symbianPrint
+#else
+int print2stdout(const char* pFmt, ...);
+int print2stderr(const char* pFmt, ...);
+#define STDOUT print2stdout
+#define STDERR print2stderr
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif /* PRINT_H */
Index: helix-libs/clientapps/clutter/shmhelp.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/shmhelp.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,88 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: shmhelp.h,v 1.5 2007/07/06 20:54:01 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+#if defined(USE_XWINDOWS)
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/XShm.h>
+#endif
+
+#include "hxcom.h"
+#include "hxtypes.h"
+
+
+class ShmHelp
+{
+  public:
+
+   //Helpers
+   static void Init(Display* pDisplay );
+   static HXBOOL ShmAvailable();
+   static HX_RESULT DetachSharedRegion(UCHAR**ppMem, XShmSegmentInfo* pInfo );
+   static HX_RESULT CreateSharedRegion( INT32 nSize,
+                                        UCHAR**ppMem,
+                                        int* pnShmID,
+                                        XShmSegmentInfo* pInfo );
+   
+
+  protected:
+   
+  private:
+   static HXBOOL zm_bUseShm;
+   
+   //The X11 Segment ID....
+   static int      zm_nSegment;
+   static Display* zm_pDisplay;
+
+   ShmHelp();
+   ShmHelp(Display*);
+   ~ShmHelp();
+   
+};
+
Index: helix-libs/clientapps/clutter/unix.pcf
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/unix.pcf	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,65 @@
+# 
+# ***** BEGIN LICENSE BLOCK ***** 
+# Version: RCSL 1.0/RPSL 1.0 
+#  
+# Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
+#      
+# The contents of this file, and the files included with this file, are 
+# subject to the current version of the RealNetworks Public Source License 
+# Version 1.0 (the "RPSL") available at 
+# http://www.helixcommunity.org/content/rpsl unless you have licensed 
+# the file under the RealNetworks Community Source License Version 1.0 
+# (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
+# in which case the RCSL will apply. You may also obtain the license terms 
+# directly from RealNetworks.  You may not use this file except in 
+# compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
+# applicable to this file, the RCSL.  Please see the applicable RPSL or 
+# RCSL for the rights, obligations and limitations governing use of the 
+# contents of the file.  
+#  
+# This file is part of the Helix DNA Technology. RealNetworks is the 
+# developer of the Original Code and owns the copyrights in the portions 
+# it created. 
+#  
+# This file, and the files included with this file, is distributed and made 
+# available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
+# EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
+# INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
+# FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
+# 
+# Technology Compatibility Kit Test Suite(s) Location: 
+#    http://www.helixcommunity.org/content/tck 
+# 
+# Contributor(s): 
+#  
+# ***** END LICENSE BLOCK ***** 
+# 
+
+
+if( ('HELIX_FEATURE_MINI_SITE' not in project.defines) and
+    (platform.name in ('linux2', 'linux-i386')) and
+    ('HELIX_FEATURE_VIDEO' in project.defines) and
+    (project.BuildOption("nodll"))
+    ):
+              project.sys_libraries.append('Xv', 'Xext')
+
+
+
+
+if project.BuildOption("nodll"):
+	if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV20"):
+		if platform.name in ('linux2', 'linux-i386', 'win32') and sysinfo.arch == 'i386':
+			project.AddLibraries(GetSDKPath("rvg2dec_libs") + '[adecg2]')
+		else:
+			project.AddLibraries(GetSDKPath("rvg2dec_libs") + '[cdecg2]')
+                
+	if project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV30") or \
+           project.IsDefined("HELIX_FEATURE_VIDEO_CODEC_RV40"):
+		if project.IsDefined("HELIX_FEATURE_ANSIC_RV89COMBO"):
+	 		project.AddLibraries(GetSDKPath("rv89combo_c_libs")+"[cdec]")
+	 	else:
+			if platform.name in ('linux2', 'linux-i386') and sysinfo.arch == 'i386':
+			        project.AddLibraries(GetSDKPath("rv89combo_libs")+"[adec40]")
+			else:
+			        project.AddLibraries(GetSDKPath("rv89combo_libs")+"[cdec40]")
+
Index: helix-libs/clientapps/clutter/unixcmap.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/unixcmap.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,51 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: unixcmap.h,v 1.3 2007/07/06 20:54:01 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+EXTERN_C Colormap HXGetXColormap(Display* pDisplay, Window window);
+EXTERN_C void HXFindBestXColor(Display* pDisplay, Colormap cmap, XColor* desired);
Index: helix-libs/clientapps/clutter/visuals.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ helix-libs/clientapps/clutter/visuals.h	2008-10-13 06:05:49.000000000 -0700
@@ -0,0 +1,74 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Source last modified: $Id: visuals.h,v 1.4 2007/07/06 20:54:01 jfinnecy Exp $
+ * 
+ * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
+ * 
+ * The contents of this file, and the files included with this file,
+ * are subject to the current version of the RealNetworks Public
+ * Source License (the "RPSL") available at
+ * http://www.helixcommunity.org/content/rpsl unless you have licensed
+ * the file under the current version of the RealNetworks Community
+ * Source License (the "RCSL") available at
+ * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
+ * will apply. You may also obtain the license terms directly from
+ * RealNetworks.  You may not use this file except in compliance with
+ * the RPSL or, if you have a valid RCSL with RealNetworks applicable
+ * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
+ * the rights, obligations and limitations governing use of the
+ * contents of the file.
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 (the
+ * "GPL") in which case the provisions of the GPL are applicable
+ * instead of those above. If you wish to allow use of your version of
+ * this file only under the terms of the GPL, and not to allow others
+ * to use your version of this file under the terms of either the RPSL
+ * or RCSL, indicate your decision by deleting the provisions above
+ * and replace them with the notice and other provisions required by
+ * the GPL. If you do not delete the provisions above, a recipient may
+ * use your version of this file under the terms of any one of the
+ * RPSL, the RCSL or the GPL.
+ * 
+ * This file is part of the Helix DNA Technology. RealNetworks is the
+ * developer of the Original Code and owns the copyrights in the
+ * portions it created.
+ * 
+ * This file, and the files included with this file, is distributed
+ * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
+ * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
+ * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
+ * ENJOYMENT OR NON-INFRINGEMENT.
+ * 
+ * Technology Compatibility Kit Test Suite(s) Location:
+ *    http://www.helixcommunity.org/content/tck
+ * 
+ * Contributor(s):
+ * 
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef _UNIX
+#error This is the UNIX platform specific implementation.
+#endif
+
+#ifndef _VISUALS_H_
+#define _VISUALS_H_
+
+#if defined(USE_XWINDOWS)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#endif
+
+//
+// These functions are loaded with dlsym() so turn off name mangling
+// with extern "C". 
+//
+extern "C" {
+
+Visual* GetBestVisual(Display* display);
+Visual* GetVisual(Display* display, long mask, XVisualInfo* templ);
+
+}
+
+#endif	// _VISUALS_H_