dlls/wineandroid.drv/WineActivity.java

   1 /*
   2  * WineActivity class
   3  *
   4  * Copyright 2013-2017 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 package org.winehq.wine;
  22
  23 import android.app.Activity;
  24 import android.app.ProgressDialog;
  25 import android.content.Context;
  26 import android.content.SharedPreferences;
  27 import android.graphics.Rect;
  28 import android.graphics.SurfaceTexture;
  29 import android.os.Build;
  30 import android.os.Bundle;
  31 import android.preference.PreferenceManager;
  32 import android.util.Log;
  33 import android.view.InputDevice;
  34 import android.view.KeyEvent;
  35 import android.view.MotionEvent;
  36 import android.view.Surface;
  37 import android.view.TextureView;
  38 import android.view.View;
  39 import android.view.ViewGroup;
  40 import java.io.BufferedReader;
  41 import java.io.File;
  42 import java.io.FileInputStream;
  43 import java.io.FileOutputStream;
  44 import java.io.IOException;
  45 import java.io.InputStream;
  46 import java.io.InputStreamReader;
  47 import java.util.ArrayList;
  48 import java.util.HashMap;
  49 import java.util.Locale;
  50 import java.util.Map;
  51
  52 public class WineActivity extends Activity
  53 {
  54     private native String wine_init( String[] cmdline, String[] env );
  55     public native void wine_desktop_changed( int width, int height );
  56     public native void wine_config_changed( int dpi );
  57     public native void wine_surface_changed( int hwnd, Surface surface, boolean opengl );
  58     public native boolean wine_motion_event( int hwnd, int action, int x, int y, int state, int vscroll );
  59     public native boolean wine_keyboard_event( int hwnd, int action, int keycode, int state );
  60
  61     private final String LOGTAG = "wine";
  62     private ProgressDialog progress_dialog;
  63
  64     protected WineWindow desktop_window;
  65     protected WineWindow message_window;
  66
  67     @Override
  68     public void onCreate(Bundle savedInstanceState)
  69     {
  70         super.onCreate( savedInstanceState );
  71
  72         requestWindowFeature( android.view.Window.FEATURE_NO_TITLE );
  73
  74         new Thread( new Runnable() { public void run() { loadWine( null ); }} ).start();
  75     }
  76
  77     private void loadWine( String cmdline )
  78     {
  79         File bindir = new File( getFilesDir(), Build.CPU_ABI + "/bin" );
  80         File libdir = new File( getFilesDir(), Build.CPU_ABI + "/lib" );
  81         File prefix = new File( getFilesDir(), "prefix" );
  82         File loader = new File( bindir, "wine" );
  83         String locale = Locale.getDefault().getLanguage() + "_" +
  84             Locale.getDefault().getCountry() + ".UTF-8";
  85
  86         copyAssetFiles();
  87
  88         HashMap<String,String> env = new HashMap<String,String>();
  89         env.put( "WINELOADER", loader.toString() );
  90         env.put( "WINEPREFIX", prefix.toString() );
  91         env.put( "LD_LIBRARY_PATH", libdir.toString() + ":" + getApplicationInfo().nativeLibraryDir );
  92         env.put( "LC_ALL", locale );
  93         env.put( "LANG", locale );
  94         env.put( "PATH", bindir.toString() + ":" + System.getenv( "PATH" ));
  95
  96         if (cmdline == null)
  97         {
  98             if (new File( prefix, "drive_c/winestart.cmd" ).exists()) cmdline = "c:\\winestart.cmd";
  99             else cmdline = "wineconsole.exe";
 100         }
 101
 102         String winedebug = readFileString( new File( prefix, "winedebug" ));
 103         if (winedebug == null) winedebug = readFileString( new File( getFilesDir(), "winedebug" ));
 104         if (winedebug != null)
 105         {
 106             File log = new File( getFilesDir(), "log" );
 107             env.put( "WINEDEBUG", winedebug );
 108             env.put( "WINEDEBUGLOG", log.toString() );
 109             Log.i( LOGTAG, "logging to " + log.toString() );
 110             log.delete();
 111         }
 112
 113         createProgressDialog( 0, "Setting up the Windows environment..." );
 114
 115         try
 116         {
 117             System.loadLibrary( "wine" );
 118         }
 119         catch (java.lang.UnsatisfiedLinkError e)
 120         {
 121             System.load( libdir.toString() + "/libwine.so" );
 122         }
 123         prefix.mkdirs();
 124
 125         runWine( cmdline, env );
 126     }
 127
 128     private final void runWine( String cmdline, HashMap<String,String> environ )
 129     {
 130         String[] env = new String[environ.size() * 2];
 131         int j = 0;
 132         for (Map.Entry<String,String> entry : environ.entrySet())
 133         {
 134             env[j++] = entry.getKey();
 135             env[j++] = entry.getValue();
 136         }
 137
 138         String[] cmd = { environ.get( "WINELOADER" ),
 139                          "explorer.exe",
 140                          "/desktop=shell,,android",
 141                          cmdline };
 142
 143         String err = wine_init( cmd, env );
 144         Log.e( LOGTAG, err );
 145     }
 146
 147     private void createProgressDialog( final int max, final String message )
 148     {
 149         runOnUiThread( new Runnable() { public void run() {
 150             if (progress_dialog != null) progress_dialog.dismiss();
 151             progress_dialog = new ProgressDialog( WineActivity.this );
 152             progress_dialog.setProgressStyle( max > 0 ? ProgressDialog.STYLE_HORIZONTAL
 153                                               : ProgressDialog.STYLE_SPINNER );
 154             progress_dialog.setTitle( "Wine" );
 155             progress_dialog.setMessage( message );
 156             progress_dialog.setCancelable( false );
 157             progress_dialog.setMax( max );
 158             progress_dialog.show();
 159         }});
 160
 161     }
 162
 163     private final boolean isFileWanted( String name )
 164     {
 165         if (name.equals( "files.sum" )) return true;
 166         if (name.startsWith( "share/" )) return true;
 167         if (name.startsWith( Build.CPU_ABI + "/system/" )) return false;
 168         if (name.startsWith( Build.CPU_ABI + "/" )) return true;
 169         if (name.startsWith( "x86/" )) return true;
 170         return false;
 171     }
 172
 173     private final boolean isFileExecutable( String name )
 174     {
 175         return name.startsWith( Build.CPU_ABI + "/" ) || name.startsWith( "x86/" );
 176     }
 177
 178     private final HashMap<String,String> readMapFromInputStream( InputStream in )
 179     {
 180         HashMap<String,String> map = new HashMap<String,String>();
 181         String str;
 182
 183         try
 184         {
 185             BufferedReader reader = new BufferedReader( new InputStreamReader( in, "UTF-8" ));
 186             while ((str = reader.readLine()) != null)
 187             {
 188                 String entry[] = str.split( "\\s+", 2 );
 189                 if (entry.length == 2 && isFileWanted( entry[1] )) map.put( entry[1], entry[0] );
 190             }
 191         }
 192         catch( IOException e ) { }
 193         return map;
 194     }
 195
 196     private final HashMap<String,String> readMapFromDiskFile( String file )
 197     {
 198         try
 199         {
 200             return readMapFromInputStream( new FileInputStream( new File( getFilesDir(), file )));
 201         }
 202         catch( IOException e ) { return new HashMap<String,String>(); }
 203     }
 204
 205     private final HashMap<String,String> readMapFromAssetFile( String file )
 206     {
 207         try
 208         {
 209             return readMapFromInputStream( getAssets().open( file ) );
 210         }
 211         catch( IOException e ) { return new HashMap<String,String>(); }
 212     }
 213
 214     private final String readFileString( File file )
 215     {
 216         try
 217         {
 218             FileInputStream in = new FileInputStream( file );
 219             BufferedReader reader = new BufferedReader( new InputStreamReader( in, "UTF-8" ));
 220             return reader.readLine();
 221         }
 222         catch( IOException e ) { return null; }
 223     }
 224
 225     private final void copyAssetFile( String src )
 226     {
 227         File dest = new File( getFilesDir(), src );
 228         try
 229         {
 230             Log.i( LOGTAG, "extracting " + dest );
 231             dest.getParentFile().mkdirs();
 232             dest.delete();
 233             if (dest.createNewFile())
 234             {
 235                 InputStream in = getAssets().open( src );
 236                 FileOutputStream out = new FileOutputStream( dest );
 237                 int read;
 238                 byte[] buffer = new byte[65536];
 239
 240                 while ((read = in.read( buffer )) > 0) out.write( buffer, 0, read );
 241                 out.close();
 242                 if (isFileExecutable( src )) dest.setExecutable( true, true );
 243             }
 244             else
 245                 Log.i( LOGTAG, "Failed to create file "  + dest );
 246         }
 247         catch( IOException e )
 248         {
 249             Log.i( LOGTAG, "Failed to copy asset file to " + dest );
 250             dest.delete();
 251         }
 252     }
 253
 254     private final void deleteAssetFile( String src )
 255     {
 256         File dest = new File( getFilesDir(), src );
 257         Log.i( LOGTAG, "deleting " + dest );
 258         dest.delete();
 259     }
 260
 261     private final void copyAssetFiles()
 262     {
 263         String new_sum = readMapFromAssetFile( "sums.sum" ).get( "files.sum" );
 264         if (new_sum == null) return;  // no assets
 265
 266         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences( this );
 267         String old_sum = prefs.getString( "files.sum", "" );
 268         if (old_sum.equals( new_sum )) return;  // no change
 269         prefs.edit().putString( "files.sum", new_sum ).apply();
 270
 271         HashMap<String,String> existing_files = readMapFromDiskFile( "files.sum" );
 272         HashMap<String,String> new_files = readMapFromAssetFile( "files.sum" );
 273         ArrayList<String> copy_files = new ArrayList<String>();
 274         copy_files.add( "files.sum" );
 275
 276         for (Map.Entry<String, String> entry : new_files.entrySet())
 277         {
 278             String name = entry.getKey();
 279             if (!entry.getValue().equals( existing_files.remove( name ))) copy_files.add( name );
 280         }
 281
 282         createProgressDialog( copy_files.size(), "Extracting files..." );
 283
 284         for (String name : existing_files.keySet()) deleteAssetFile( name );
 285
 286         for (String name : copy_files)
 287         {
 288             copyAssetFile( name );
 289             runOnUiThread( new Runnable() { public void run() {
 290                 progress_dialog.incrementProgressBy( 1 ); }});
 291         }
 292     }
 293
 294     //
 295     // Generic Wine window class
 296     //
 297
 298     private HashMap<Integer,WineWindow> win_map = new HashMap<Integer,WineWindow>();
 299
 300     protected class WineWindow extends Object
 301     {
 302         static protected final int HWND_MESSAGE = 0xfffffffd;
 303         static protected final int SWP_NOZORDER = 0x04;
 304         static protected final int WS_VISIBLE = 0x10000000;
 305
 306         protected int hwnd;
 307         protected int owner;
 308         protected int style;
 309         protected boolean visible;
 310         protected Rect visible_rect;
 311         protected Rect client_rect;
 312         protected WineWindow parent;
 313         protected ArrayList<WineWindow> children;
 314         protected Surface window_surface;
 315         protected Surface client_surface;
 316         protected SurfaceTexture window_surftex;
 317         protected SurfaceTexture client_surftex;
 318         protected WineWindowGroup window_group;
 319         protected WineWindowGroup client_group;
 320
 321         public WineWindow( int w, WineWindow parent )
 322         {
 323             Log.i( LOGTAG, String.format( "create hwnd %08x", w ));
 324             hwnd = w;
 325             owner = 0;
 326             style = 0;
 327             visible = false;
 328             visible_rect = client_rect = new Rect( 0, 0, 0, 0 );
 329             this.parent = parent;
 330             children = new ArrayList<WineWindow>();
 331             win_map.put( w, this );
 332             if (parent != null) parent.children.add( this );
 333         }
 334
 335         public void destroy()
 336         {
 337             Log.i( LOGTAG, String.format( "destroy hwnd %08x", hwnd ));
 338             visible = false;
 339             win_map.remove( this );
 340             if (parent != null) parent.children.remove( this );
 341             destroy_window_groups();
 342         }
 343
 344         public WineWindowGroup create_window_groups()
 345         {
 346             if (client_group != null) return client_group;
 347             window_group = new WineWindowGroup( this );
 348             client_group = new WineWindowGroup( this );
 349             window_group.addView( client_group );
 350             client_group.set_layout( client_rect.left - visible_rect.left,
 351                                      client_rect.top - visible_rect.top,
 352                                      client_rect.right - visible_rect.left,
 353                                      client_rect.bottom - visible_rect.top );
 354             if (parent != null)
 355             {
 356                 parent.create_window_groups();
 357                 if (visible) add_view_to_parent();
 358                 window_group.set_layout( visible_rect.left, visible_rect.top,
 359                                          visible_rect.right, visible_rect.bottom );
 360             }
 361             return client_group;
 362         }
 363
 364         public void destroy_window_groups()
 365         {
 366             if (window_group != null)
 367             {
 368                 if (parent != null && parent.client_group != null) remove_view_from_parent();
 369                 window_group.destroy_view();
 370             }
 371             if (client_group != null) client_group.destroy_view();
 372             window_group = null;
 373             client_group = null;
 374         }
 375
 376         public View create_whole_view()
 377         {
 378             if (window_group == null) create_window_groups();
 379             window_group.create_view( false ).layout( 0, 0, visible_rect.right - visible_rect.left,
 380                                                       visible_rect.bottom - visible_rect.top );
 381             return window_group;
 382         }
 383
 384         public void create_client_view()
 385         {
 386             if (client_group == null) create_window_groups();
 387             Log.i( LOGTAG, String.format( "creating client view %08x %s", hwnd, client_rect ));
 388             client_group.create_view( true ).layout( 0, 0, client_rect.right - client_rect.left,
 389                                                      client_rect.bottom - client_rect.top );
 390         }
 391
 392         protected void add_view_to_parent()
 393         {
 394             int pos = parent.client_group.getChildCount() - 1;
 395
 396             // the content view is always last
 397             if (pos >= 0 && parent.client_group.getChildAt( pos ) == parent.client_group.get_content_view()) pos--;
 398
 399             for (int i = 0; i < parent.children.size() && pos >= 0; i++)
 400             {
 401                 WineWindow child = parent.children.get( i );
 402                 if (child == this) break;
 403                 if (!child.visible) continue;
 404                 if (child == ((WineWindowGroup)parent.client_group.getChildAt( pos )).get_window()) pos--;
 405             }
 406             parent.client_group.addView( window_group, pos + 1 );
 407         }
 408
 409         protected void remove_view_from_parent()
 410         {
 411             parent.client_group.removeView( window_group );
 412         }
 413
 414         protected void set_zorder( WineWindow prev )
 415         {
 416             int pos = -1;
 417
 418             parent.children.remove( this );
 419             if (prev != null) pos = parent.children.indexOf( prev );
 420             parent.children.add( pos + 1, this );
 421         }
 422
 423         protected void sync_views_zorder()
 424         {
 425             int i, j;
 426
 427             for (i = parent.children.size() - 1, j = 0; i >= 0; i--)
 428             {
 429                 WineWindow child = parent.children.get( i );
 430                 if (!child.visible) continue;
 431                 View child_view = parent.client_group.getChildAt( j );
 432                 if (child_view == parent.client_group.get_content_view()) continue;
 433                 if (child != ((WineWindowGroup)child_view).get_window()) break;
 434                 j++;
 435             }
 436             while (i >= 0)
 437             {
 438                 WineWindow child = parent.children.get( i-- );
 439                 if (child.visible) child.window_group.bringToFront();
 440             }
 441         }
 442
 443         public void pos_changed( int flags, int insert_after, int owner, int style,
 444                                  Rect window_rect, Rect client_rect, Rect visible_rect )
 445         {
 446             boolean was_visible = visible;
 447             this.visible_rect = visible_rect;
 448             this.client_rect = client_rect;
 449             this.style = style;
 450             this.owner = owner;
 451             visible = (style & WS_VISIBLE) != 0;
 452
 453             Log.i( LOGTAG, String.format( "pos changed hwnd %08x after %08x owner %08x style %08x win %s client %s visible %s flags %08x",
 454                                           hwnd, insert_after, owner, style, window_rect, client_rect, visible_rect, flags ));
 455
 456             if ((flags & SWP_NOZORDER) == 0 && parent != null) set_zorder( get_window( insert_after ));
 457
 458             if (window_group != null)
 459             {
 460                 window_group.set_layout( visible_rect.left, visible_rect.top,
 461                                          visible_rect.right, visible_rect.bottom );
 462                 if (parent != null)
 463                 {
 464                     if (!was_visible && (style & WS_VISIBLE) != 0) add_view_to_parent();
 465                     else if (was_visible && (style & WS_VISIBLE) == 0) remove_view_from_parent();
 466                     else if (visible && (flags & SWP_NOZORDER) == 0) sync_views_zorder();
 467                 }
 468             }
 469
 470             if (client_group != null)
 471                 client_group.set_layout( client_rect.left - visible_rect.left,
 472                                          client_rect.top - visible_rect.top,
 473                                          client_rect.right - visible_rect.left,
 474                                          client_rect.bottom  - visible_rect.top );
 475         }
 476
 477         public void set_parent( WineWindow new_parent )
 478         {
 479             Log.i( LOGTAG, String.format( "set parent hwnd %08x parent %08x -> %08x",
 480                                           hwnd, parent.hwnd, new_parent.hwnd ));
 481             if (window_group != null)
 482             {
 483                 if (visible) remove_view_from_parent();
 484                 new_parent.create_window_groups();
 485                 window_group.set_layout( visible_rect.left, visible_rect.top,
 486                                          visible_rect.right, visible_rect.bottom );
 487             }
 488             parent.children.remove( this );
 489             parent = new_parent;
 490             parent.children.add( this );
 491             if (visible && window_group != null) add_view_to_parent();
 492         }
 493
 494         public int get_hwnd()
 495         {
 496             return hwnd;
 497         }
 498
 499         public void set_surface( SurfaceTexture surftex, boolean is_client )
 500         {
 501             if (is_client)
 502             {
 503                 if (surftex == null) client_surface = null;
 504                 else if (surftex != client_surftex)
 505                 {
 506                     client_surftex = surftex;
 507                     client_surface = new Surface( surftex );
 508                 }
 509                 Log.i( LOGTAG, String.format( "set client surface hwnd %08x %s", hwnd, client_surface ));
 510                 wine_surface_changed( hwnd, client_surface, true );
 511             }
 512             else
 513             {
 514                 if (surftex == null) window_surface = null;
 515                 else if (surftex != window_surftex)
 516                 {
 517                     window_surftex = surftex;
 518                     window_surface = new Surface( surftex );
 519                 }
 520                 Log.i( LOGTAG, String.format( "set window surface hwnd %08x %s", hwnd, window_surface ));
 521                 wine_surface_changed( hwnd, window_surface, false );
 522             }
 523         }
 524
 525         public void get_event_pos( MotionEvent event, int[] pos )
 526         {
 527             pos[0] = Math.round( event.getX() + window_group.getLeft() );
 528             pos[1] = Math.round( event.getY() + window_group.getTop() );
 529         }
 530     }
 531
 532     //
 533     // Window group for a Wine window, optionally containing a content view
 534     //
 535
 536     protected class WineWindowGroup extends ViewGroup
 537     {
 538         private WineView content_view;
 539         private WineWindow win;
 540
 541         WineWindowGroup( WineWindow win )
 542         {
 543             super( WineActivity.this );
 544             this.win = win;
 545             setVisibility( View.VISIBLE );
 546         }
 547
 548         /* wrapper for layout() making sure that the view is not empty */
 549         public void set_layout( int left, int top, int right, int bottom )
 550         {
 551             if (right <= left + 1) right = left + 2;
 552             if (bottom <= top + 1) bottom = top + 2;
 553             layout( left, top, right, bottom );
 554         }
 555
 556         @Override
 557         protected void onLayout( boolean changed, int left, int top, int right, int bottom )
 558         {
 559             if (content_view != null) content_view.layout( 0, 0, right - left, bottom - top );
 560         }
 561
 562         public WineView create_view( boolean is_client )
 563         {
 564             if (content_view != null) return content_view;
 565             content_view = new WineView( WineActivity.this, win, is_client );
 566             addView( content_view );
 567             if (!is_client)
 568             {
 569                 content_view.setFocusable( true );
 570                 content_view.setFocusableInTouchMode( true );
 571             }
 572             return content_view;
 573         }
 574
 575         public void destroy_view()
 576         {
 577             if (content_view == null) return;
 578             removeView( content_view );
 579             content_view = null;
 580         }
 581
 582         public WineView get_content_view()
 583         {
 584             return content_view;
 585         }
 586
 587         public WineWindow get_window()
 588         {
 589             return win;
 590         }
 591     }
 592
 593     // View used for all Wine windows, backed by a TextureView
 594
 595     protected class WineView extends TextureView implements TextureView.SurfaceTextureListener
 596     {
 597         private WineWindow window;
 598         private boolean is_client;
 599
 600         public WineView( Context c, WineWindow win, boolean client )
 601         {
 602             super( c );
 603             window = win;
 604             is_client = client;
 605             setSurfaceTextureListener( this );
 606             setVisibility( VISIBLE );
 607             setOpaque( false );
 608             setFocusable( true );
 609             setFocusableInTouchMode( true );
 610         }
 611
 612         public WineWindow get_window()
 613         {
 614             return window;
 615         }
 616
 617         public void onSurfaceTextureAvailable( SurfaceTexture surftex, int width, int height )
 618         {
 619             Log.i( LOGTAG, String.format( "onSurfaceTextureAvailable win %08x %dx%d %s",
 620                                           window.hwnd, width, height, is_client ? "client" : "whole" ));
 621             window.set_surface( surftex, is_client );
 622         }
 623
 624         public void onSurfaceTextureSizeChanged( SurfaceTexture surftex, int width, int height )
 625         {
 626             Log.i( LOGTAG, String.format( "onSurfaceTextureSizeChanged win %08x %dx%d %s",
 627                                           window.hwnd, width, height, is_client ? "client" : "whole" ));
 628             window.set_surface( surftex, is_client);
 629         }
 630
 631         public boolean onSurfaceTextureDestroyed( SurfaceTexture surftex )
 632         {
 633             Log.i( LOGTAG, String.format( "onSurfaceTextureDestroyed win %08x %s",
 634                                           window.hwnd, is_client ? "client" : "whole" ));
 635             window.set_surface( null, is_client );
 636             return false;  // hold on to the texture since the app may still be using it
 637         }
 638
 639         public void onSurfaceTextureUpdated(SurfaceTexture surftex)
 640         {
 641         }
 642
 643         public boolean onGenericMotionEvent( MotionEvent event )
 644         {
 645             if (is_client) return false;  // let the whole window handle it
 646             if (window.parent != null && window.parent != desktop_window) return false;  // let the parent handle it
 647
 648             if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0)
 649             {
 650                 int[] pos = new int[2];
 651                 window.get_event_pos( event, pos );
 652                 Log.i( LOGTAG, String.format( "view motion event win %08x action %d pos %d,%d buttons %04x view %d,%d",
 653                                               window.hwnd, event.getAction(), pos[0], pos[1],
 654                                               event.getButtonState(), getLeft(), getTop() ));
 655                 return wine_motion_event( window.hwnd, event.getAction(), pos[0], pos[1],
 656                                           event.getButtonState(), (int)event.getAxisValue(MotionEvent.AXIS_VSCROLL)  );
 657             }
 658             return super.onGenericMotionEvent(event);
 659         }
 660
 661         public boolean onTouchEvent( MotionEvent event )
 662         {
 663             if (is_client) return false;  // let the whole window handle it
 664             if (window.parent != null && window.parent != desktop_window) return false;  // let the parent handle it
 665
 666             int[] pos = new int[2];
 667             window.get_event_pos( event, pos );
 668             Log.i( LOGTAG, String.format( "view touch event win %08x action %d pos %d,%d buttons %04x view %d,%d",
 669                                           window.hwnd, event.getAction(), pos[0], pos[1],
 670                                           event.getButtonState(), getLeft(), getTop() ));
 671             return wine_motion_event( window.hwnd, event.getAction(), pos[0], pos[1],
 672                                       event.getButtonState(), 0 );
 673         }
 674
 675         public boolean dispatchKeyEvent( KeyEvent event )
 676         {
 677             Log.i( LOGTAG, String.format( "view key event win %08x action %d keycode %d (%s)",
 678                                           window.hwnd, event.getAction(), event.getKeyCode(),
 679                                           event.keyCodeToString( event.getKeyCode() )));;
 680             boolean ret = wine_keyboard_event( window.hwnd, event.getAction(), event.getKeyCode(),
 681                                                event.getMetaState() );
 682             if (!ret) ret = super.dispatchKeyEvent(event);
 683             return ret;
 684         }
 685     }
 686
 687     // The top-level desktop view group
 688
 689     protected class TopView extends ViewGroup
 690     {
 691         public TopView( Context context, int hwnd )
 692         {
 693             super( context );
 694             desktop_window = new WineWindow( hwnd, null );
 695             addView( desktop_window.create_whole_view() );
 696             desktop_window.client_group.bringToFront();
 697
 698             message_window = new WineWindow( WineWindow.HWND_MESSAGE, null );
 699             message_window.create_window_groups();
 700         }
 701
 702         @Override
 703         protected void onSizeChanged( int width, int height, int old_width, int old_height )
 704         {
 705             Log.i( LOGTAG, String.format( "desktop size %dx%d", width, height ));
 706             wine_desktop_changed( width, height );
 707         }
 708
 709         @Override
 710         protected void onLayout( boolean changed, int left, int top, int right, int bottom )
 711         {
 712             // nothing to do
 713         }
 714     }
 715
 716     protected WineWindow get_window( int hwnd )
 717     {
 718         return win_map.get( hwnd );
 719     }
 720
 721     // Entry points for the device driver
 722
 723     public void create_desktop_window( int hwnd )
 724     {
 725         Log.i( LOGTAG, String.format( "create desktop view %08x", hwnd ));
 726         setContentView( new TopView( this, hwnd ));
 727         progress_dialog.dismiss();
 728         wine_config_changed( getResources().getConfiguration().densityDpi );
 729     }
 730
 731     public void create_window( int hwnd, boolean opengl, int parent, int pid )
 732     {
 733         WineWindow win = get_window( hwnd );
 734         if (win == null)
 735         {
 736             win = new WineWindow( hwnd, get_window( parent ));
 737             win.create_window_groups();
 738             if (win.parent == desktop_window) win.create_whole_view();
 739         }
 740         if (opengl) win.create_client_view();
 741     }
 742
 743     public void destroy_window( int hwnd )
 744     {
 745         WineWindow win = get_window( hwnd );
 746         if (win != null) win.destroy();
 747     }
 748
 749     public void set_window_parent( int hwnd, int parent, int pid )
 750     {
 751         WineWindow win = get_window( hwnd );
 752         if (win == null) return;
 753         win.set_parent( get_window( parent ));
 754         if (win.parent == desktop_window) win.create_whole_view();
 755     }
 756
 757     public void window_pos_changed( int hwnd, int flags, int insert_after, int owner, int style,
 758                                     Rect window_rect, Rect client_rect, Rect visible_rect )
 759     {
 760         WineWindow win = get_window( hwnd );
 761         if (win != null)
 762             win.pos_changed( flags, insert_after, owner, style, window_rect, client_rect, visible_rect );
 763     }
 764
 765     public void createDesktopWindow( final int hwnd )
 766     {
 767         runOnUiThread( new Runnable() { public void run() { create_desktop_window( hwnd ); }} );
 768     }
 769
 770     public void createWindow( final int hwnd, final boolean opengl, final int parent, final int pid )
 771     {
 772         runOnUiThread( new Runnable() { public void run() { create_window( hwnd, opengl, parent, pid ); }} );
 773     }
 774
 775     public void destroyWindow( final int hwnd )
 776     {
 777         runOnUiThread( new Runnable() { public void run() { destroy_window( hwnd ); }} );
 778     }
 779
 780     public void setParent( final int hwnd, final int parent, final int pid )
 781     {
 782         runOnUiThread( new Runnable() { public void run() { set_window_parent( hwnd, parent, pid ); }} );
 783     }
 784
 785     public void windowPosChanged( final int hwnd, final int flags, final int insert_after,
 786                                   final int owner, final int style,
 787                                   final int window_left, final int window_top,
 788                                   final int window_right, final int window_bottom,
 789                                   final int client_left, final int client_top,
 790                                   final int client_right, final int client_bottom,
 791                                   final int visible_left, final int visible_top,
 792                                   final int visible_right, final int visible_bottom )
 793     {
 794         final Rect window_rect = new Rect( window_left, window_top, window_right, window_bottom );
 795         final Rect client_rect = new Rect( client_left, client_top, client_right, client_bottom );
 796         final Rect visible_rect = new Rect( visible_left, visible_top, visible_right, visible_bottom );
 797         runOnUiThread( new Runnable() {
 798             public void run() { window_pos_changed( hwnd, flags, insert_after, owner, style,
 799                                                     window_rect, client_rect, visible_rect ); }} );
 800     }
 801 }