~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

public override java.awt.dnd.DragGestureRecognizer createDragGestureRecognizer(java.lang.Class abstractRecognizerClass, java.awt.dnd.DragSource ds, java.awt.Component c, int srcActions, java.awt.dnd.DragGestureListener dgl)

670

{

671

java.lang.Class clazz = typeof(java.awt.dnd.MouseDragGestureRecognizer);

672

if (abstractRecognizerClass == clazz)

673

return new NetMouseDragGestureRecognizer(ds, c, srcActions, dgl);

674

else

675

return null;

676

}

677

678

public override java.awt.dnd.peer.DragSourceContextPeer createDragSourceContextPeer(java.awt.dnd.DragGestureEvent dge)

679

{

680

return NetDragSourceContextPeer.createDragSourceContextPeer(dge);

681

}

682

683

public override Map mapInputMethodHighlight(java.awt.im.InputMethodHighlight highlight)

684

{

685

throw new NotImplementedException();

686

}

687

688

#if false

689

protected override java.awt.peer.LightweightPeer createComponent(java.awt.Component target)

690

{

691

if(target is java.awt.Container)

692

{

693

return new NetLightweightContainerPeer((java.awt.Container)target);

694

}

695

return new NetLightweightComponentPeer(target);

696

}

697

#endif

698

699

/* public override java.awt.Font createFont(int format, java.io.InputStream stream)

700

{

701

throw new NotImplementedException();

702

}

703

704

public override gnu.java.awt.peer.ClasspathFontPeer getClasspathFontPeer(string name, java.util.Map attrs)

705

{

706

return new NetFontPeer(name, attrs);

707

}

708

709

public override java.awt.GraphicsEnvironment getLocalGraphicsEnvironment()

710

{

711

return new NetGraphicsEnvironment();

712

}

713

714

public override RobotPeer createRobot(java.awt.GraphicsDevice screen)

715

{

716

if (Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32Windows)

717

{

718

return new WindowsRobot(screen);

719

}

720

throw new java.awt.AWTException("Robot not supported for this OS");

721

}

722

723

public override gnu.java.awt.peer.EmbeddedWindowPeer createEmbeddedWindow(gnu.java.awt.EmbeddedWindow ew)

724

{

725

throw new NotImplementedException();

726

}

727

728

protected override java.awt.peer.DesktopPeer createDesktopPeer(java.awt.Desktop target)

729

{

730

return new NetDesktopPeer();

731

}

732

733

public override java.awt.Dimension getBestCursorSize(int preferredWidth, int preferredHeight)

734

{

735

// TODO

736

return new java.awt.Dimension(preferredWidth, preferredHeight);

737

}

738

739

public override java.awt.Cursor createCustomCursor(java.awt.Image cursor, java.awt.Point hotSpot, string name)

740

{

741

return new NetCustomCursor(cursor, hotSpot, name);

742

}

743

744

private object getRegistry(string subKey, string valueName)

745

{

746

using (Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(subKey, false))

747

{

748

return key == null ? null : key.GetValue(valueName);

749

}

750

}

751

752

protected override void initializeDesktopProperties()

753

{

754

//copied from WToolkit.java

755

desktopProperties.put("DnD.Autoscroll.initialDelay", java.lang.Integer.valueOf(50));

756

desktopProperties.put("DnD.Autoscroll.interval", java.lang.Integer.valueOf(50));

757

758

try

759

{

760

if (isWin32())

761

{

762

desktopProperties.put("Shell.shellFolderManager", "sun.awt.shell.Win32ShellFolderManager2" );

763

object themeActive = getRegistry("Software\\Microsoft\\Windows\\CurrentVersion\\ThemeManager", "ThemeActive");

764

// string dllName = (string)getRegistry("Software\\Microsoft\\Windows\\CurrentVersion\\ThemeManager", "DllName");

765

// string sizeName = (string)getRegistry("Software\\Microsoft\\Windows\\CurrentVersion\\ThemeManager", "SizeName");

766

// string colorName = (string)getRegistry("Software\\Microsoft\\Windows\\CurrentVersion\\ThemeManager", "ColorName");

767

desktopProperties.put("win.xpstyle.themeActive", java.lang.Boolean.valueOf("1".Equals(themeActive)));

768

// desktopProperties.put("win.xpstyle.dllName", dllName);

769

// desktopProperties.put("win.xpstyle.sizeName", sizeName);

770

// desktopProperties.put("win.xpstyle.colorName", colorName);

771

}

772

}

773

catch (java.lang.ClassNotFoundException)

774

{

775

}

776

}

777

778

protected override Object lazilyLoadDesktopProperty(String name)

779

{

780

if ("win.defaultGUI.font".Equals(name))

781

{

782

Font font = Control.DefaultFont;

783

return C2J.ConvertFont(font);

784

}

785

return null;

786

}

787

788

protected override java.awt.peer.MouseInfoPeer getMouseInfoPeer() {

789

return new NetMouseInfoPeer();

790

}

791

792

/*===============================

793

* Implementations of interface IkvmToolkit

794

795

796

public java.awt.Graphics2D createGraphics(System.Drawing.Bitmap bitmap)

797

{

798

return new BitmapGraphics(bitmap);

799

}

800

801

/// <summary>

802

/// Get a helper class for implementing the print API

803

/// </summary>

804

/// <returns></returns>

805

public sun.print.PrintPeer getPrintPeer()

806

{

807

if (isWin32())

808

{

809

return new Win32PrintPeer();

810

}

811

else

812

{

813

return new LinuxPrintPeer();

814

}

815

}

816

817

/// <summary>

818

/// Create a outline from the given text and font parameter

819

/// </summary>

820

/// <param name="javaFont">the font</param>

821

/// <param name="frc">font render context</param>

822

/// <param name="text">the text</param>

823

/// <param name="x">x - position</param>

824

/// <param name="y">y - position</param>

825

/// <returns></returns>

826

public java.awt.Shape outline(java.awt.Font javaFont, java.awt.font.FontRenderContext frc, string text, float x, float y) {

827

GraphicsPath path = new GraphicsPath(FillMode.Winding);

828

Font netFont = javaFont.getNetFont();

829

FontFamily family = netFont.FontFamily;

830

FontStyle style = netFont.Style;

831

float factor = netFont.Size / family.GetEmHeight(style);

832

float ascent = family.GetCellAscent(style) * factor;

833

y -= ascent;

834

835

StringFormat format = new StringFormat(StringFormat.GenericTypographic);

836

format.FormatFlags = StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap | StringFormatFlags.FitBlackBox;

837

format.Trimming = StringTrimming.None;

838

839

path.AddString(text, family, (int)style, netFont.Size, new PointF(x, y), format);

840

return C2J.ConvertShape(path);

841

}

842

843

/*===============================

844

* Implementations of interface SunToolkit

845

846

847

public override bool isModalExclusionTypeSupported(java.awt.Dialog.ModalExclusionType dmet)

848

{

849

return false;

850

}

851

852

public override bool isModalityTypeSupported(java.awt.Dialog.ModalityType type)

853

{

854

return type.ordinal() == java.awt.Dialog.ModalityType.MODELESS.ordinal() ||

855

type.ordinal() == java.awt.Dialog.ModalityType.APPLICATION_MODAL.ordinal();

856

}

857

858

public override java.awt.Window createInputMethodWindow(string __p1, sun.awt.im.InputContext __p2)

859

{

860

throw new NotImplementedException();

861

}

862

863

public override java.awt.peer.RobotPeer createRobot(java.awt.Robot r, java.awt.GraphicsDevice screen)

864

{

865

if (isWin32())

866

{

867

return new WindowsRobot(screen);

868

}

869

throw new java.awt.AWTException("Robot not supported for this OS");

870

}

871

872

public override java.awt.peer.SystemTrayPeer createSystemTray(java.awt.SystemTray target)

873

{

874

NetSystemTrayPeer peer = new NetSystemTrayPeer(target);

875

targetCreatedPeer(target, peer);

876

return peer;

877

}

878

879

public override java.awt.peer.TrayIconPeer createTrayIcon(java.awt.TrayIcon target)

880

{

881

NetTrayIconPeer peer = new NetTrayIconPeer(target);

882

targetCreatedPeer(target, peer);

883

return peer;

884

}

885

886

public override java.awt.im.spi.InputMethodDescriptor getInputMethodAdapterDescriptor()

887

{

888

return null;

889

}

890

891

protected override int getScreenHeight()

892

{

893

return Screen.PrimaryScreen.Bounds.Height;

894

}

895

896

protected override int getScreenWidth()

897

{

898

return Screen.PrimaryScreen.Bounds.Width;

899

}

900

901

public override java.awt.Insets getScreenInsets(java.awt.GraphicsConfiguration gc)

902

{

903

NetGraphicsConfiguration ngc = gc as NetGraphicsConfiguration;

904

if (ngc != null)

905

{

906

Rectangle rectWorkingArea = ngc.screen.WorkingArea;

907

Rectangle rectBounds = ngc.screen.Bounds;

908

return new java.awt.Insets(

909

rectWorkingArea.Top - rectBounds.Top,

910

rectWorkingArea.Left - rectBounds.Left,

911

rectBounds.Bottom - rectWorkingArea.Bottom,

912

rectBounds.Right - rectWorkingArea.Right);

913

}

914

else

915

{

916

return base.getScreenInsets(gc);

917

}

918

}

919

920

public override void grab(java.awt.Window window)

921

{

922

NetWindowPeer peer = (NetWindowPeer)window.getPeer();

923

if (peer != null)

924

{

925

peer.Grab();

926

}

927

}

928

929

public override bool isDesktopSupported()

930

{

931

return true;

932

}

933

934

public override bool isTraySupported()

935

{

936

return true;

937

}

938

939

public override bool isFrameStateSupported(int state)

940

{

941

switch (state)

942

{

943

case java.awt.Frame.NORMAL:

944

case java.awt.Frame.ICONIFIED:

945

case java.awt.Frame.MAXIMIZED_BOTH:

946

return true;

947

default:

948

return false;

949

}

950

}

951

952

protected override bool syncNativeQueue(long l)

953

{

954

throw new NotImplementedException();

955

}

956

957

public override void ungrab(java.awt.Window window)

958

{

959

NetWindowPeer peer = (NetWindowPeer)window.getPeer();

960

if (peer != null)

961

{

962

peer.Ungrab(false);

963

}

964

}

965

966

internal new static object targetToPeer(object target)

967

{

968

return SunToolkit.targetToPeer(target);

969

}

970

971

internal new static void targetDisposedPeer(object target, object peer)

972

{

973

SunToolkit.targetDisposedPeer(target, peer);

974

}

975

976

internal static void BeginInvoke(MethodInvoker del)

977

{

978

if (WinFormsMessageLoop.InvokeRequired)

979

{

980

WinFormsMessageLoop.BeginInvoke(del);

981

}

982

else

983

{

984

del();

985

}

986

}

987

988

internal static void BeginInvoke<T>(Action<T> del, T t)

989

{

990

if (WinFormsMessageLoop.InvokeRequired)

991

{

992

WinFormsMessageLoop.BeginInvoke(del, t);

993

}

994

else

995

{

996

del(t);

997

}

998

}

999

internal static void Invoke<T>(Action<T> del, T t)

1000

{

1001

if (WinFormsMessageLoop.InvokeRequired)

1002

{

1003

WinFormsMessageLoop.Invoke(del, t);

1004

}

1005

else

1006

{

1007

del(t);

1008

}

1009

}

1010

1011

internal static TResult Invoke<TResult>(Func<TResult> del)

1012

{

1013

if (WinFormsMessageLoop.InvokeRequired)

1014

{

1015

return (TResult)WinFormsMessageLoop.Invoke(del);

1016

}

1017

else

1018

{

1019

return del();

1020

}

1021

}

1022

1023

internal static void Invoke(MethodInvoker del)

1024

{

1025

if (WinFormsMessageLoop.InvokeRequired)

1026

{

1027

WinFormsMessageLoop.Invoke(del);

1028

}

1029

else

1030

{

1031

del();

1032

}

1033

}

1034

1035

public override bool areExtraMouseButtonsEnabled()

1036

{

1037

return true;

1038

}

1039

}

1040

1041

sealed class NetMenuBarPeer : java.awt.peer.MenuBarPeer

1042

{

1043

internal readonly MainMenu menu = new MainMenu();

1044

1045

internal NetMenuBarPeer(java.awt.MenuBar target)

1046

{

1047

menu.Tag = target;

1048

for (int i = 0; i < target.getMenuCount(); i++)

1049

{

1050

addMenu(target.getMenu(i));

1051

}

1052

}

1053

1054

public void addHelpMenu(java.awt.Menu m)

1055

{

1056

addMenu(m);

1057

}

1058

1059

public void addMenu(java.awt.Menu m)

1060

{

1061

if (m.getPeer() == null)

1062

{

1063

m.addNotify();

1064

}

1065

NetToolkit.Invoke(delegate { menu.MenuItems.Add(((NetMenuPeer)m.getPeer()).menu); });

1066

}

1067

1068

public void delMenu(int i)

1069

{

1070

NetToolkit.Invoke(delegate { menu.MenuItems.RemoveAt(i); });

1071

}

1072

1073

public void dispose()

1074

{

1075

NetToolkit.Invoke(delegate { menu.Dispose(); });

1076

}

1077

1078

public void setFont(java.awt.Font f)

1079

{

1080

throw new NotImplementedException();

1081

}

1082

}

1083

1084

sealed class NetMenuPeer : java.awt.peer.MenuPeer

1085

{

1086

internal readonly MenuItem menu = new MenuItem();

1087

1088

internal NetMenuPeer(java.awt.Menu target)

1089

{

1090

menu.Tag = target;

1091

menu.Text = target.getLabel();

1092

for (int i = 0; i < target.getItemCount(); i++)

1093

{

1094

addItem(target.getItem(i));

1095

}

1096

}

1097

1098

public void addItem(java.awt.MenuItem item)

1099

{

1100

if (item.getPeer() == null)

1101

{

1102

item.addNotify();

1103

}

1104

if (item.getPeer() is NetMenuItemPeer)

1105

{

1106

NetToolkit.Invoke(delegate { menu.MenuItems.Add(((NetMenuItemPeer)item.getPeer()).menuitem); });

1107

}

1108

else

1109

{

1110

NetToolkit.Invoke(delegate { menu.MenuItems.Add(((NetMenuPeer)item.getPeer()).menu); });

1111

}

1112

}

1113

1114

public void addSeparator()

1115

{

1116

NetToolkit.Invoke(delegate { menu.MenuItems.Add(new MenuItem("-")); });

1117

}

1118

1119

public void delItem(int i)

1120

{

1121

NetToolkit.Invoke(delegate { menu.MenuItems.RemoveAt(i); });

1122

}

1123

1124

public void dispose()

1125

{

1126

NetToolkit.Invoke(delegate { menu.Dispose(); });

1127

}

1128

1129

public void setFont(java.awt.Font f)

1130

{

1131

throw new NotImplementedException();

1132

}

1133

1134

public void disable()

1135

{

1136

setEnabled(false);

1137

}

1138

1139

public void enable()

1140

{

1141

setEnabled(true);

1142

}

1143

1144

public void setEnabled(bool b)

1145

{

1146

NetToolkit.Invoke(delegate { menu.Enabled = b; });

1147

}

1148

1149

public void setLabel(string str)

1150

{

1151

NetToolkit.Invoke(delegate { menu.Text = str; });

1152

}

1153

}

1154

1155

class NetMenuItemPeer : java.awt.peer.MenuItemPeer

1156

{

1157

protected readonly java.awt.MenuItem target;

1158

internal readonly MenuItem menuitem = new MenuItem();

1159

1160

internal NetMenuItemPeer(java.awt.MenuItem target)

1161

{

1162

this.target = target;

1163

setEnabled(target.isEnabled());

1164

setLabel(target.getLabel());

1165

menuitem.Click += OnClick;

1166

}

1167

1168

protected virtual void OnClick(object sender, EventArgs e)

1169

{

1170

long when = java.lang.System.currentTimeMillis();

1171

int modifiers = NetComponentPeer.GetModifiers(Control.ModifierKeys);

1172

NetToolkit.executeOnEventHandlerThread(target, Delegates.toRunnable(delegate

1173

{

1174

NetToolkit.postEvent(NetToolkit.targetToAppContext(target), new java.awt.@event.ActionEvent(target, java.awt.@event.ActionEvent.ACTION_PERFORMED,

1175

target.getActionCommand(), when, modifiers));

1176

}));

1177

}

1178

1179

public void disable()

1180

{

1181

setEnabled(false);

1182

}

1183

1184

public void enable()

1185

{

1186

setEnabled(true);

1187

}

1188

1189

public void setEnabled(bool b)

1190

{

1191

NetToolkit.Invoke(delegate { menuitem.Enabled = b; });

1192

}

1193

1194

public void setLabel(string str)

1195

{

1196

NetToolkit.Invoke(delegate { menuitem.Text = str; });

1197

}

1198

1199

public void dispose()

1200

{

1201

NetToolkit.Invoke(delegate { menuitem.Dispose(); });

1202

}

1203

1204

public void setFont(java.awt.Font f)

1205

{

1206

}

1207

}

1208

1209

sealed class NetCheckboxMenuItemPeer : NetMenuItemPeer, java.awt.peer.CheckboxMenuItemPeer

1210

{

1211

internal NetCheckboxMenuItemPeer(java.awt.CheckboxMenuItem target)

1212

: base(target)

1213

{

1214

setState(target.getState());

1215

}

1216

1217

protected override void OnClick(object sender, EventArgs e)

1218

{

1219

java.awt.CheckboxMenuItem target = (java.awt.CheckboxMenuItem)this.target;

1220

NetToolkit.executeOnEventHandlerThread(target, Delegates.toRunnable(delegate

1221

{

1222

bool state = !menuitem.Checked;

1223

target.setState(state);

1224

NetToolkit.postEvent(NetToolkit.targetToAppContext(target), new java.awt.@event.ItemEvent(target, java.awt.@event.ItemEvent.ITEM_STATE_CHANGED,

1225

target.getLabel(), (state)

1226

? java.awt.@event.ItemEvent.SELECTED

1227

: java.awt.@event.ItemEvent.DESELECTED));

1228

}));

1229

}

1230

1231

public void setState(bool b)

1232

{

1233

NetToolkit.Invoke(delegate { menuitem.Checked = b; });

1234

}

1235

}

1236

1237

internal class NetDragSourceContextPeer : sun.awt.dnd.SunDragSourceContextPeer

1238

{

1239

private static readonly NetDragSourceContextPeer theInstance = new NetDragSourceContextPeer(null);

1240

private bool dragStart = false;

1241

1242

private NetDragSourceContextPeer(java.awt.dnd.DragGestureEvent dge) : base(dge)

1243

{

1244

}

1245

1246

public static NetDragSourceContextPeer createDragSourceContextPeer(java.awt.dnd.DragGestureEvent dge)

1247

{

1248

theInstance.setTrigger(dge);

1249

return theInstance;

1250

}

1251

1252

public override void startSecondaryEventLoop()

1253

{

1254

//NetToolkit.startSecondaryEventLoop();

1255

}

1256

1257

public override void quitSecondaryEventLoop()

1258

{

1259

//NetToolkit.quitSecondaryEventLoop();

1260

}

1261

1262

internal static new java.awt.dnd.DragSourceContext getDragSourceContext()

1263

{

1264

return theInstance.getDragSourceContextCore();

1265

}

1266

1267

internal static NetDragSourceContextPeer getInstance()

1268

{

1269

return theInstance;

1270

}

1271

1272

internal java.awt.dnd.DragSourceContext getDragSourceContextCore()

1273

{

1274

return base.getDragSourceContext();

1275

}

1276

1277

internal new void dragDropFinished(bool success, int operations, int x, int y)

1278

{

1279

if (dragStart)

1280

{

1281

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

1282

base.dragDropFinished(success, operations, x, y);

1283

}));

1284

}

1285

dragStart = false;

1286

}

1287

1288

protected override void startDrag(java.awt.datatransfer.Transferable trans, long[] formats, Map formatMap)

1289

{

1290

dragStart = true;

1291

1292

createDragSource(getTrigger().getComponent(),

1293

trans,

1294

getTrigger().getTriggerEvent(),

1295

getTrigger().getSourceAsDragGestureRecognizer().getSourceActions(),

1296

formats,

1297

formatMap);

1298

NetDropTargetContextPeer.setCurrentJVMLocalSourceTransferable(trans);

1299

}

1300

1301

private long createDragSource(java.awt.Component component,

1302

java.awt.datatransfer.Transferable transferable,

1303

java.awt.@event.InputEvent nativeTrigger,

1304

int actions,

1305

long[] formats,

1306

Map formatMap)

1307

{

1308

java.awt.Component controlOwner = component;

1309

while (controlOwner!=null && (controlOwner.getPeer() == null || controlOwner.getPeer() is sun.awt.NullComponentPeer))

1310

{

1311

controlOwner = controlOwner.getParent();

1312

}

1313

if (controlOwner != null)

1314

{

1315

NetComponentPeer peer = controlOwner.getPeer() as NetComponentPeer;

1316

if (peer != null)

1317

{

1318

peer.performedDragDropEffects = DragDropEffects.None;

1319

Control control = peer.Control;

1320

if (control != null)

1321

{

1322

java.awt.dnd.DragSource dragSource = getTrigger().getDragSource();

1323

IDataObject data = NetDataTransferer.getInstanceImpl().getDataObject(transferable,

1324

NetDataTransferer.adaptFlavorMap(dragSource.getFlavorMap()));

1325

NetToolkit.BeginInvoke(delegate

1326

{

1327

DragDropEffects effects = control.DoDragDrop(data, DragDropEffects.All);

1328

if (effects == DragDropEffects.None && peer.performedDragDropEffects!=DragDropEffects.None)

1329

{

1330

effects = peer.performedDragDropEffects;

1331

}

1332

peer.performedDragDropEffects = DragDropEffects.None;

1333

dragDropFinished(effects != DragDropEffects.None,

1334

NetComponentPeer.getAction(effects),

1335

Control.MousePosition.X, Control.MousePosition.Y);

1336

});

1337

}

1338

}

1339

}

1340

return 0;

1341

}

1342

1343

protected override void setNativeCursor(long nativeCtxt, java.awt.Cursor c, int cType)

1344

{

1345

1346

}

1347

}

1348

1349

internal class NetDropTargetContextPeer : sun.awt.dnd.SunDropTargetContextPeer

1350

{

1351

private IDataObject data;

1352

1353

internal static NetDropTargetContextPeer getNetDropTargetContextPeer()

1354

{

1355

return new NetDropTargetContextPeer();

1356

}

1357

1358

internal int handleEnterMessage(java.awt.Component component,

1359

int x, int y,

1360

int dropAction,

1361

int actions,

1362

long[] formats,

1363

long nativeCtxt)

1364

{

1365

return postDropTargetEvent(component, x, y, dropAction, actions,

1366

formats, nativeCtxt,

1367

sun.awt.dnd.SunDropTargetEvent.MOUSE_ENTERED,

1368

sun.awt.dnd.SunDropTargetContextPeer.DISPATCH_SYNC);

1369

}

1370

1371

internal void handleExitMessage(java.awt.Component component,

1372

long nativeCtxt)

1373

{

1374

postDropTargetEvent(component, 0, 0, java.awt.dnd.DnDConstants.ACTION_NONE,

1375

java.awt.dnd.DnDConstants.ACTION_NONE, null, nativeCtxt,

1376

sun.awt.dnd.SunDropTargetEvent.MOUSE_EXITED,

1377

sun.awt.dnd.SunDropTargetContextPeer.DISPATCH_SYNC);

1378

}

1379

1380

internal int handleMotionMessage(java.awt.Component component,

1381

int x, int y,

1382

int dropAction,

1383

int actions, long[] formats,

1384

long nativeCtxt)

1385

{

1386

return postDropTargetEvent(component, x, y, dropAction, actions,

1387

formats, nativeCtxt,

1388

sun.awt.dnd.SunDropTargetEvent.MOUSE_DRAGGED,

1389

sun.awt.dnd.SunDropTargetContextPeer.DISPATCH_SYNC);

1390

}

1391

1392

internal void handleDropMessage(java.awt.Component component,

1393

int x, int y,

1394

int dropAction, int actions,

1395

long[] formats,

1396

long nativeCtxt, IDataObject data)

1397

{

1398

this.data = data;

1399

postDropTargetEvent(component, x, y, dropAction, actions,

1400

formats, nativeCtxt,

1401

sun.awt.dnd.SunDropTargetEvent.MOUSE_DROPPED,

1402

!sun.awt.dnd.SunDropTargetContextPeer.DISPATCH_SYNC);

1403

}

1404

1405

internal new int postDropTargetEvent(java.awt.Component component,

1406

int x, int y,

1407

int dropAction,

1408

int actions,

1409

long[] formats,

1410

long nativeCtxt,

1411

int eventID,

1412

bool dispatchType)

1413

{

1414

return base.postDropTargetEvent(component, x, y,

1415

dropAction, actions, formats, nativeCtxt, eventID, dispatchType);

1416

}

1417

1418

protected override void doDropDone(bool success, int dropAction, bool isLocal)

1419

{

1420

// Don't do anything as .NET framework already handle the message pump

1421

}

1422

1423

public override bool isDataFlavorSupported(java.awt.datatransfer.DataFlavor df)

1424

{

1425

if (isTransferableJVMLocal())

1426

return base.isDataFlavorSupported(df);

1427

return base.isDataFlavorSupported(df);

1428

}

1429

1430

public override object getTransferData(java.awt.datatransfer.DataFlavor df)

1431

{

1432

if (isTransferableJVMLocal())

1433

return base.getTransferData(df);

1434

return new NetClipboardTransferable(data).getTransferData(df);

1435

}

1436

1437

protected override object getNativeData(long l)

1438

{

1439

throw new NotImplementedException();

1440

}

1441

}

1442

1443

internal class NetMouseDragGestureRecognizer : java.awt.dnd.MouseDragGestureRecognizer

1444

{

1445

protected static int motionThreshold;

1446

1447

protected static readonly int ButtonMask = java.awt.@event.InputEvent.BUTTON1_DOWN_MASK |

1448

java.awt.@event.InputEvent.BUTTON2_DOWN_MASK |

1449

java.awt.@event.InputEvent.BUTTON3_DOWN_MASK;

1450

1451

public NetMouseDragGestureRecognizer(java.awt.dnd.DragSource source, java.awt.Component component1, int actions,

1452

java.awt.dnd.DragGestureListener listener) :

1453

base(source, component1, actions, listener)

1454

{

1455

}

1456

1457

protected int mapDragOperationFromModifiers(java.awt.@event.MouseEvent e)

1458

{

1459

int mods = e.getModifiersEx();

1460

int btns = mods & ButtonMask;

1461

1462

// Prohibit multi-button drags.

1463

if (!(btns == java.awt.@event.InputEvent.BUTTON1_DOWN_MASK ||

1464

btns == java.awt.@event.InputEvent.BUTTON2_DOWN_MASK ||

1465

btns == java.awt.@event.InputEvent.BUTTON3_DOWN_MASK))

1466

{

1467

return java.awt.dnd.DnDConstants.ACTION_NONE;

1468

}

1469

1470

return

1471

sun.awt.dnd.SunDragSourceContextPeer.convertModifiersToDropAction(mods,

1472

getSourceActions());

1473

}

1474

1475

public override void mouseClicked(java.awt.@event.MouseEvent e)

1476

{

1477

// do nothing

1478

}

1479

1480

public override void mousePressed(java.awt.@event.MouseEvent e)

1481

{

1482

events.clear();

1483

1484

if (mapDragOperationFromModifiers(e) != java.awt.dnd.DnDConstants.ACTION_NONE)

1485

{

1486

try

1487

{

1488

motionThreshold = java.awt.dnd.DragSource.getDragThreshold();

1489

}

1490

catch

1491

{

1492

motionThreshold = 5;

1493

}

1494

appendEvent(e);

1495

}

1496

}

1497

1498

public override void mouseReleased(java.awt.@event.MouseEvent e)

1499

{

1500

events.clear();

1501

}

1502

1503

public override void mouseEntered(java.awt.@event.MouseEvent e)

1504

{

1505

events.clear();

1506

}

1507

1508

public override void mouseExited(java.awt.@event.MouseEvent e)

1509

{

1510

if (!events.isEmpty())

1511

{ // gesture pending

1512

int dragAction = mapDragOperationFromModifiers(e);

1513

1514

if (dragAction == java.awt.dnd.DnDConstants.ACTION_NONE)

1515

{

1516

events.clear();

1517

}

1518

}

1519

}

1520

1521

public override void mouseDragged(java.awt.@event.MouseEvent e)

1522

{

1523

if (!events.isEmpty())

1524

{ // gesture pending

1525

int dop = mapDragOperationFromModifiers(e);

1526

1527

if (dop == java.awt.dnd.DnDConstants.ACTION_NONE)

1528

{

1529

return;

1530

}

1531

1532

java.awt.@event.MouseEvent trigger = (java.awt.@event.MouseEvent)events.get(0);

1533

1534

1535

java.awt.Point origin = trigger.getPoint();

1536

java.awt.Point current = e.getPoint();

1537

1538

int dx = java.lang.Math.abs(origin.x - current.x);

1539

int dy = java.lang.Math.abs(origin.y - current.y);

1540

1541

if (dx > motionThreshold || dy > motionThreshold)

1542

{

1543

fireDragGestureRecognized(dop, ((java.awt.@event.MouseEvent)getTriggerEvent()).getPoint());

1544

}

1545

else

1546

appendEvent(e);

1547

}

1548

}

1549

1550

}

1551

1552

class NetInputMethodDescriptor : java.awt.im.spi.InputMethodDescriptor

1553

{

1554

public java.awt.im.spi.InputMethod createInputMethod()

1555

{

1556

throw new NotImplementedException();

1557

}

1558

1559

public Locale[] getAvailableLocales()

1560

{

1561

// TODO Feature with .NET 3.0 available

1562

//IEnumerable languages = System.Windows.Input.InputLanguageManager.AvailableInputLanguages;

1563

// as a hack we return the default locale

1564

return new Locale[]{Locale.getDefault()};

1565

}

1566

1567

public string getInputMethodDisplayName(Locale inputLocale, Locale displayLanguage)

1568

{

1569

// copied from WInputMethodDescriptor

1570

1571

// We ignore the input locale.

1572

// When displaying for the default locale, rely on the localized AWT properties;

1573

// for any other locale, fall back to English.

1574

String name = "System Input Methods";

1575

if (Locale.getDefault().equals(displayLanguage))

1576

{

1577

name = java.awt.Toolkit.getProperty("AWT.HostInputMethodDisplayName", name);

1578

}

1579

return name;

1580

}

1581

1582

public java.awt.Image getInputMethodIcon(Locale l)

1583

{

1584

//WInputMethodDescriptor return also ever null

1585

return null;

1586

}

1587

1588

public bool hasDynamicLocaleList()

1589

{

1590

// Java return also true

1591

return true;

1592

}

1593

}

1594

1595

class NetCustomCursor : java.awt.Cursor

1596

{

1597

private Cursor cursor;

1598

public Cursor Cursor

1599

{

1600

get { return cursor; }

1601

}

1602

1603

internal NetCustomCursor(java.awt.Image cursorIm, java.awt.Point hotSpot, String name) // throws IndexOutOfBoundsException

1604

: base(name)

1605

{

1606

java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();

1607

1608

// Make sure image is fully loaded.

1609

java.awt.Component c = new java.awt.Canvas(); // for its imageUpdate method

1610

java.awt.MediaTracker tracker = new java.awt.MediaTracker(c);

1611

tracker.addImage(cursorIm, 0);

1612

try

1613

{

1614

tracker.waitForAll();

1615

}

1616

catch (java.lang.InterruptedException)

1617

{

1618

}

1619

int width = cursorIm.getWidth(c);

1620

int height = cursorIm.getHeight(c);

1621

1622

// Fix for bug 4212593 The Toolkit.createCustomCursor does not

1623

// check absence of the image of cursor

1624

// If the image is invalid, the cursor will be hidden (made completely

1625

// transparent). In this case, getBestCursorSize() will adjust negative w and h,

1626

// but we need to set the hotspot inside the image here.

1627

if (tracker.isErrorAny() || width < 0 || height < 0)

1628

{

1629

hotSpot.x = hotSpot.y = 0;

1630

}

1631

1632

// Scale image to nearest supported size.

1633

java.awt.Dimension nativeSize = toolkit.getBestCursorSize(width, height);

1634

if (nativeSize.width != width || nativeSize.height != height)

1635

{

1636

cursorIm = cursorIm.getScaledInstance(nativeSize.width,

1637

nativeSize.height,

1638

java.awt.Image.SCALE_DEFAULT);

1639

width = nativeSize.width;

1640

height = nativeSize.height;

1641

}

1642

1643

// Verify that the hotspot is within cursor bounds.

1644

if (hotSpot.x >= width || hotSpot.y >= height || hotSpot.x < 0 || hotSpot.y < 0)

1645

{

1646

throw new ArgumentException("invalid hotSpot");

1647

}

1648

1649

Bitmap bitmap = J2C.ConvertImage(cursorIm);

1650

IntPtr hIcon = bitmap.GetHicon();

1651

cursor = new Cursor(hIcon);

1652

}

1653

}

1654

1655

sealed class NetLightweightComponentPeer : NetComponentPeer<java.awt.Component, Control>, java.awt.peer.LightweightPeer

1656

{

1657

public NetLightweightComponentPeer(java.awt.Component target)

1658

: base(target)

1659

{

1660

}

1661

1662

protected override Control CreateControl()

1663

{

1664

throw new NotImplementedException();

1665

}

1666

}

1667

1668

sealed class NetLightweightContainerPeer : NetContainerPeer<java.awt.Container, ContainerControl>, java.awt.peer.LightweightPeer

1669

{

1670

public NetLightweightContainerPeer(java.awt.Container target)

1671

: base(target)

1672

{

1673

}

1674

}

1675

1676

abstract class NetComponentPeer : java.awt.peer.ComponentPeer

1677

{

1678

internal bool eraseBackground = true;

1679

1680

public abstract void applyShape(sun.java2d.pipe.Region r);

1681

public abstract bool canDetermineObscurity();

1682

public abstract int checkImage(java.awt.Image i1, int i2, int i3, java.awt.image.ImageObserver io);

1683

public abstract void coalescePaintEvent(java.awt.@event.PaintEvent pe);

1684

public abstract void createBuffers(int i, java.awt.BufferCapabilities bc);

1685

public abstract java.awt.Image createImage(int i1, int i2);

1686

public abstract java.awt.Image createImage(java.awt.image.ImageProducer ip);

1687

public abstract java.awt.image.VolatileImage createVolatileImage(int i1, int i2);

1688

public abstract void destroyBuffers();

1689

public abstract void disable();

1690

public abstract void dispose();

1691

public abstract void enable();

1692

public abstract void flip(java.awt.BufferCapabilities.FlipContents bcfc);

1693

public abstract java.awt.Image getBackBuffer();

1694

public abstract java.awt.Rectangle getBounds();

1695

public abstract java.awt.image.ColorModel getColorModel();

1696

public abstract java.awt.FontMetrics getFontMetrics(java.awt.Font f);

1697

public abstract java.awt.Graphics getGraphics();

1698

public abstract java.awt.GraphicsConfiguration getGraphicsConfiguration();

1699

public abstract java.awt.Point getLocationOnScreen();

1700

public abstract java.awt.Dimension getMinimumSize();

1701

public abstract java.awt.Dimension getPreferredSize();

1702

public abstract java.awt.Toolkit getToolkit();

1703

public abstract void handleEvent(java.awt.AWTEvent awte);

1704

public abstract bool handlesWheelScrolling();

1705

public abstract void hide();

1706

public abstract bool isFocusable();

1707

public abstract bool isObscured();

1708

public abstract bool isReparentSupported();

1709

public abstract void layout();

1710

public abstract java.awt.Dimension minimumSize();

1711

public abstract void paint(java.awt.Graphics g);

1712

public abstract java.awt.Dimension preferredSize();

1713

public abstract bool prepareImage(java.awt.Image i1, int i2, int i3, java.awt.image.ImageObserver io);

1714

public abstract void print(java.awt.Graphics g);

1715

public abstract void repaint(long l, int i1, int i2, int i3, int i4);

1716

public abstract void reparent(java.awt.peer.ContainerPeer cp);

1717

public abstract bool requestFocus(java.awt.Component c, bool b1, bool b2, long l, CausedFocusEvent.Cause cfec);

1718

public abstract void reshape(int i1, int i2, int i3, int i4);

1719

public abstract void setBackground(java.awt.Color c);

1720

public abstract void setBounds(int i1, int i2, int i3, int i4, int i5);

1721

public abstract void setEnabled(bool b);

1722

public abstract void setFont(java.awt.Font f);

1723

public abstract void setForeground(java.awt.Color c);

1724

public abstract void setVisible(bool b);

1725

public abstract void show();

1726

public abstract void updateCursorImmediately();

1727

public abstract void flip(int x1, int y1, int x2, int y2, java.awt.BufferCapabilities.FlipContents flipAction);

1728

public abstract void setZOrder(java.awt.peer.ComponentPeer above);

1729

public abstract bool updateGraphicsData(java.awt.GraphicsConfiguration gc);

1730

1731

internal DragDropEffects performedDragDropEffects = DragDropEffects.None;

1732

1733

internal abstract Control Control { get; }

1734

internal abstract java.awt.Component Target { get; }

1735

1736

internal abstract int getInsetsLeft();

1737

internal abstract int getInsetsTop();

1738

1739

internal static int getAction(DragDropEffects effects)

1740

{

1741

int actions = java.awt.dnd.DnDConstants.ACTION_NONE;

1742

switch (effects)

1743

{

1744

case DragDropEffects.None:

1745

actions = java.awt.dnd.DnDConstants.ACTION_NONE;

1746

break;

1747

case DragDropEffects.Copy:

1748

actions = java.awt.dnd.DnDConstants.ACTION_COPY;

1749

break;

1750

case DragDropEffects.Move:

1751

actions = java.awt.dnd.DnDConstants.ACTION_MOVE;

1752

break;

1753

case DragDropEffects.Move | DragDropEffects.Copy:

1754

actions = java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE;

1755

break;

1756

case DragDropEffects.Link:

1757

actions = java.awt.dnd.DnDConstants.ACTION_LINK;

1758

break;

1759

}

1760

return actions;

1761

}

1762

1763

internal static int GetMouseEventModifiers(MouseEventArgs ev)

1764

{

1765

int modifiers = GetModifiers(Control.ModifierKeys);

1766

//Which button was pressed or released, because it can only one that it is a switch

1767

MouseButtons button = ev.Button;

1768

switch (button)

1769

{

1770

case MouseButtons.Left:

1771

modifiers |= java.awt.@event.InputEvent.BUTTON1_MASK;

1772

break;

1773

case MouseButtons.Middle:

1774

modifiers |= java.awt.@event.InputEvent.BUTTON2_MASK;

1775

break;

1776

case MouseButtons.Right:

1777

modifiers |= java.awt.@event.InputEvent.BUTTON3_MASK;

1778

break;

1779

}

1780

return modifiers;

1781

}

1782

1783

internal static int GetModifiers(Keys keys)

1784

{

1785

int modifiers = 0;

1786

if ((keys & Keys.Shift) != 0)

1787

{

1788

modifiers |= java.awt.@event.InputEvent.SHIFT_DOWN_MASK;

1789

}

1790

switch (keys & (Keys.Control | Keys.Alt))

1791

{

1792

case Keys.Control:

1793

modifiers |= java.awt.@event.InputEvent.CTRL_DOWN_MASK;

1794

break;

1795

case Keys.Alt:

1796

modifiers |= java.awt.@event.InputEvent.ALT_DOWN_MASK;

1797

break;

1798

case Keys.Control | Keys.Alt:

1799

modifiers |= java.awt.@event.InputEvent.ALT_GRAPH_DOWN_MASK;

1800

break;

1801

}

1802

if ((Control.MouseButtons & MouseButtons.Left) != 0)

1803

{

1804

modifiers |= java.awt.@event.InputEvent.BUTTON1_DOWN_MASK;

1805

}

1806

if ((Control.MouseButtons & MouseButtons.Middle) != 0)

1807

{

1808

modifiers |= java.awt.@event.InputEvent.BUTTON2_DOWN_MASK;

1809

}

1810

if ((Control.MouseButtons & MouseButtons.Right) != 0)

1811

{

1812

modifiers |= java.awt.@event.InputEvent.BUTTON3_DOWN_MASK;

1813

}

1814

return modifiers;

1815

}

1816

1817

internal static int GetButton(MouseEventArgs e)

1818

{

1819

if ((e.Button & MouseButtons.Left) != 0)

1820

{

1821

return java.awt.@event.MouseEvent.BUTTON1;

1822

}

1823

else if ((e.Button & MouseButtons.Middle) != 0)

1824

{

1825

return java.awt.@event.MouseEvent.BUTTON2;

1826

}

1827

else if ((e.Button & MouseButtons.Right) != 0)

1828

{

1829

return java.awt.@event.MouseEvent.BUTTON3;

1830

}

1831

else

1832

{

1833

return java.awt.@event.MouseEvent.NOBUTTON;

1834

}

1835

}

1836

1837

internal static NetComponentPeer FromControl(Control control)

1838

{

1839

return (NetComponentPeer)control.Tag;

1840

}

1841

}

1842

1843

abstract class NetComponentPeer<T, C> : NetComponentPeer

1844

where T : java.awt.Component

1845

where C : Control

1846

{

1847

protected static readonly java.awt.Font defaultFont = new java.awt.Font(java.awt.Font.DIALOG, java.awt.Font.PLAIN, 12);

1848

internal readonly T target;

1849

internal readonly C control;

1850

private bool isMouseClick;

1851

private bool isDoubleClick;

1852

private bool isPopupMenu;

1853

private int oldWidth = -1;

1854

private int oldHeight = -1;

1855

private bool sm_suppressFocusAndActivation;

1856

//private bool m_callbacksEnabled;

1857

//private int m_validationNestCount;

1858

private int serialNum = 0;

1859

private bool isLayouting = false;

1860

private bool paintPending = false;

1861

private RepaintArea paintArea;

1862

private java.awt.Font font;

1863

private java.awt.Color foreground;

1864

private java.awt.Color background;

1865

private volatile bool disposed;

1866

private NetDropTargetContextPeer dropTargetPeer;

1867

1868

internal override Control Control

1869

{

1870

get { return control; }

1871

}

1872

1873

internal override java.awt.Component Target

1874

{

1875

get { return target; }

1876

}

1877

1878

public NetComponentPeer(T target)

1879

{

1880

this.target = target;

1881

this.paintArea = new RepaintArea();

1882

java.awt.Container parent = SunToolkit.getNativeContainer(target);

1883

NetComponentPeer parentPeer = (NetComponentPeer)NetToolkit.targetToPeer(parent);

1884

control = Create(parentPeer);

1885

// fix for 5088782: check if window object is created successfully

1886

//checkCreation();

1887

//this.winGraphicsConfig = (NetGraphicsConfiguration)getGraphicsConfiguration();

1888

1889

this.surfaceData =

1890

winGraphicsConfig.createSurfaceData(this, numBackBuffers);

1891

1892

initialize();

1893

start(); // Initialize enable/disable state, turn on callbacks

1894

}

1895

1896

protected virtual void initialize()

1897

{

1898

if (target.isVisible())

1899

{

1900

show(); // the wnd starts hidden

1901

}

1902

java.awt.Color fg = target.getForeground();

1903

if (fg != null)

1904

{

1905

setForeground(fg);

1906

}

1907

// Set background color in C++, to avoid inheriting a parent's color.

1908

java.awt.Font f = target.getFont();

1909

if (f != null)

1910

{

1911

setFont(f);

1912

}

1913

if (!target.isEnabled())

1914

{

1915

disable();

1916

}

1917

java.awt.Rectangle r = target.getBounds();

1918

setBounds(r.x, r.y, r.width, r.height, java.awt.peer.ComponentPeer.__Fields.SET_BOUNDS);

1919

1920

// this is from initialize() in WCanvasPeer.java

1921

eraseBackground = !SunToolkit.getSunAwtNoerasebackground();

1922

if (!PaintEventDispatcher.getPaintEventDispatcher().shouldDoNativeBackgroundErase(target))

1923

{

1924

eraseBackground = false;

1925

}

1926

}

1927

1928

void start()

1929

{

1930

NetToolkit.BeginInvoke(delegate

1931

{

1932

hookEvents();

1933

// JDK native code also disables the window here, but since that is already done in initialize(),

1934

// I don't see the point

1935

EnableCallbacks(true);

1936

control.Invalidate();

1937

control.Update();

1938

});

1939

}

1940

1941

void EnableCallbacks(bool enabled)

1942

{

1943

//m_callbacksEnabled = enabled;

1944

}

1945

1946

private C Create(NetComponentPeer parent)

1947

{

1948

C control = CreateControl();

1949

control.Tag = this;

1950

if (parent != null)

1951

{

1952

Form form = control as Form;

1953

if (form != null)

1954

{

1955

form.Owner = parent.Control.FindForm();

1956

}

1957

else

1958

{

1959

control.Parent = parent.Control;

1960

}

1961

}

1962

NetToolkit.CreateNative(control);

1963

return control;

1964

}

1965

1966

protected abstract C CreateControl();

1967

1968

void pShow()

1969

{

1970

NetToolkit.BeginInvoke(delegate { control.Visible = true; });

1971

}

1972

1973

void Enable(bool enable)

1974

{

1975

sm_suppressFocusAndActivation = true;

1976

control.Enabled = enable;

1977

sm_suppressFocusAndActivation = false;

1978

}

1979

1980

internal virtual void hookEvents()

1981

{

1982

// TODO we really only should hook these events when they are needed...

1983

control.KeyDown += new KeyEventHandler(OnKeyDown);

1984

control.KeyUp += new KeyEventHandler(OnKeyUp);

1985

control.KeyPress += new KeyPressEventHandler(OnKeyPress);

1986

control.MouseMove += new MouseEventHandler(OnMouseMove);

1987

control.MouseDown += new MouseEventHandler(OnMouseDown);

1988

control.MouseWheel += new MouseEventHandler(OnMouseWheel);

1989

control.Click += new EventHandler(OnClick);

1990

control.DoubleClick += new EventHandler(OnDoubleClick);

1991

control.MouseUp += new MouseEventHandler(OnMouseUp);

1992

control.MouseEnter += new EventHandler(OnMouseEnter);

1993

control.MouseLeave += new EventHandler(OnMouseLeave);

1994

control.GotFocus += new EventHandler(OnGotFocus);

1995

control.LostFocus += new EventHandler(OnLostFocus);

1996

//control.Leave += new EventHandler(OnBoundsChanged);

1997

control.Paint += new PaintEventHandler(OnPaint);

1998

control.ContextMenu = new ContextMenu();

1999

control.ContextMenu.Popup += new EventHandler(OnPopupMenu);

2000

control.AllowDrop = true;

2001

control.DragDrop += new DragEventHandler(OnDragDrop);

2002

control.DragOver += new DragEventHandler(OnDragOver);

2003

control.DragLeave += new EventHandler(OnDragLeave);

2004

control.DragEnter += new DragEventHandler(OnDragEnter);

2005

control.QueryContinueDrag += new QueryContinueDragEventHandler(OnQueryContinueDrag);

2006

}

2007

2008

internal virtual void unhookEvents()

2009

{

2010

control.KeyDown -= new KeyEventHandler(OnKeyDown);

2011

control.KeyUp -= new KeyEventHandler(OnKeyUp);

2012

control.KeyPress -= new KeyPressEventHandler(OnKeyPress);

2013

control.MouseMove -= new MouseEventHandler(OnMouseMove);

2014

control.MouseDown -= new MouseEventHandler(OnMouseDown);

2015

control.MouseWheel -= new MouseEventHandler(OnMouseWheel);

2016

control.Click -= new EventHandler(OnClick);

2017

control.DoubleClick -= new EventHandler(OnDoubleClick);

2018

control.MouseUp -= new MouseEventHandler(OnMouseUp);

2019

control.MouseEnter -= new EventHandler(OnMouseEnter);

2020

control.MouseLeave -= new EventHandler(OnMouseLeave);

2021

control.GotFocus -= new EventHandler(OnGotFocus);

2022

control.LostFocus -= new EventHandler(OnLostFocus);

2023

//control.Leave -= new EventHandler(OnBoundsChanged);

2024

control.Paint -= new PaintEventHandler(OnPaint);

2025

control.DragDrop -= new DragEventHandler(OnDragDrop);

2026

control.DragOver -= new DragEventHandler(OnDragOver);

2027

control.DragLeave -= new EventHandler(OnDragLeave);

2028

control.DragEnter -= new DragEventHandler(OnDragEnter);

2029

if (control.ContextMenu != null)

2030

control.ContextMenu.Popup -= new EventHandler(OnPopupMenu);

2031

}

2032

2033

protected void SendEvent(java.awt.AWTEvent evt)

2034

{

2035

postEvent(evt);

2036

}

2037

2038

/// <summary>

2039

/// Get the left insets of the .NET Window.

2040

/// In .NET the coordinate of a window start on the most left, top point with 0,0

2041

/// In Java the most left, top point with 0,0 is in the detail area of the window.

2042

/// In all not Windows Component this return ever 0.

2043

/// </summary>

2044

/// <returns></returns>

2045

internal override int getInsetsLeft()

2046

{

2047

return 0;

2048

}

2049

2050

/// <summary>

2051

/// Get the top insets of the .NET Window.

2052

/// In .NET the coordinate of a window start on the most left, top point with 0,0

2053

/// In Java the most left, top point with 0,0 is in the detail area of the window.

2054

/// In all not Windows Component this return ever 0.

2055

/// </summary>

2056

/// <returns></returns>

2057

internal override int getInsetsTop()

2058

{

2059

return 0;

2060

}

2061

2062

2063

/// <summary>

2064

/// .NET calculates the offset relative to the detail area.

2065

/// Java uses the top left point of a window.

2066

/// That means we must compensate the coordinate of a component

2067

/// if the parent is a window, frame or dialog.

2068

/// </summary>

2069

/// <returns>The offset of the details area in the parent</returns>

2070

private Point getParentOffset()

2071

{

2072

if (!(target is java.awt.Window))

2073

{

2074

java.awt.Container parent = target.getParent();

2075

if (parent != null)

2076

{

2077

NetComponentPeer peer = parent.getPeer() as NetComponentPeer;

2078

if (peer != null)

2079

{

2080

return new Point(peer.getInsetsLeft(), peer.getInsetsTop());

2081

}

2082

}

2083

}

2084

return new Point();

2085

}

2086

2087

private void OnPaint(object sender, PaintEventArgs e)

2088

{

2089

//CheckFontSmoothingSettings(GetHWnd());

2090

/* Set draw state */

2091

//SetDrawState(GetDrawState() | JAWT_LOCK_CLIP_CHANGED);

2092

WmPaint(e.Graphics, e.ClipRectangle);

2093

}

2094

2095

private void WmPaint(Graphics g, Rectangle r)

2096

{

2097

handlePaint(r.X + getInsetsLeft(), r.Y + getInsetsTop(), r.Width, r.Height);

2098

}

2099

2100

/* Invoke a paint() method call on the target, without clearing the

2101

* damaged area. This is normally called by a native control after

2102

* it has painted itself.

2103

2104

* NOTE: This is called on the privileged toolkit thread. Do not

2105

* call directly into user code using this thread!

2106

2107

private void handlePaint(int x, int y, int w, int h)

2108

{

2109

postPaintIfNecessary(x, y, w, h);

2110

}

2111

2112

private void postPaintIfNecessary(int x, int y, int w, int h)

2113

{

2114

if (!AWTAccessor.getComponentAccessor().getIgnoreRepaint(target))

2115

{

2116

java.awt.@event.PaintEvent evt = PaintEventDispatcher.getPaintEventDispatcher().createPaintEvent(target, x, y, w, h);

2117

if (evt != null)

2118

{

2119

postEvent(evt);

2120

}

2121

}

2122

}

2123

2124

private static int MapKeyCode(Keys key)

2125

{

2126

switch (key)

2127

{

2128

case Keys.Delete:

2129

return java.awt.@event.KeyEvent.VK_DELETE;

2130

2131

case Keys.Enter:

2132

return java.awt.@event.KeyEvent.VK_ENTER;

2133

2134

default:

2135

return (int)key;

2136

}

2137

}

2138

2139

private void OnKeyDown(object sender, KeyEventArgs e)

2140

{

2141

long when = java.lang.System.currentTimeMillis();

2142

int modifiers = GetModifiers(e.Modifiers);

2143

int keyCode = MapKeyCode(e.KeyCode);

2144

// TODO set keyChar

2145

char keyChar = ' ';

2146

int keyLocation = java.awt.@event.KeyEvent.KEY_LOCATION_STANDARD;

2147

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2148

postEvent(new java.awt.@event.KeyEvent(target, java.awt.@event.KeyEvent.KEY_PRESSED, when, modifiers, keyCode, keyChar, keyLocation));

2149

}));

2150

}

2151

2152

private void OnQueryContinueDrag(object sender, QueryContinueDragEventArgs e)

2153

{

2154

}

2155

2156

private void OnDragEnter(object sender, DragEventArgs e)

2157

{

2158

IDataObject obj = e.Data;

2159

long[] formats = NetDataTransferer.getInstanceImpl().getClipboardFormatCodes(obj.GetFormats());

2160

dropTargetPeer = NetDropTargetContextPeer.getNetDropTargetContextPeer();

2161

int actions = dropTargetPeer.handleEnterMessage(target, e.X, e.Y, getDropAction(e.AllowedEffect, e.KeyState), getAction(e.AllowedEffect),

2162

formats, 0);

2163

e.Effect = getDragDropEffects(actions);

2164

}

2165

2166

private void OnDragOver(object sender, DragEventArgs e)

2167

{

2168

IDataObject obj = e.Data;

2169

long[] formats = NetDataTransferer.getInstanceImpl().getClipboardFormatCodes(obj.GetFormats());

2170

dropTargetPeer = NetDropTargetContextPeer.getNetDropTargetContextPeer();

2171

int actions = dropTargetPeer.handleMotionMessage(target, e.X, e.Y, getDropAction(e.AllowedEffect, e.KeyState), getAction(e.AllowedEffect),

2172

formats, 0);

2173

e.Effect = getDragDropEffects(actions);

2174

}

2175

2176

private void OnDragLeave(object sender, EventArgs e)

2177

{

2178

if (dropTargetPeer!=null)

2179

dropTargetPeer.handleExitMessage(target, 0);

2180

dropTargetPeer = null;

2181

}

2182

2183

private void OnDragDrop(object sender, DragEventArgs e)

2184

{

2185

IDataObject obj = e.Data;

2186

long[] formats = NetDataTransferer.getInstanceImpl().getClipboardFormatCodes(obj.GetFormats());

2187

int actions = getAction(e.Effect);

2188

if (dropTargetPeer != null)

2189

dropTargetPeer.handleDropMessage(target, e.X, e.Y, getAction(e.Effect), getAction(e.AllowedEffect),

2190

formats, 0, e.Data);

2191

NetDragSourceContextPeer.getInstance().dragDropFinished(true, actions, e.X, e.Y);

2192

performedDragDropEffects = e.Effect;

2193

dropTargetPeer = null;

2194

}

2195

2196

private static DragDropEffects getDragDropEffects(int actions)

2197

{

2198

switch(actions)

2199

{

2200

case java.awt.dnd.DnDConstants.ACTION_COPY:

2201

return DragDropEffects.Copy;

2202

case java.awt.dnd.DnDConstants.ACTION_MOVE:

2203

return DragDropEffects.Move;

2204

case java.awt.dnd.DnDConstants.ACTION_COPY_OR_MOVE:

2205

return DragDropEffects.Move | DragDropEffects.Copy;

2206

case java.awt.dnd.DnDConstants.ACTION_LINK:

2207

return DragDropEffects.Link;

2208

default:

2209

return DragDropEffects.None;

2210

}

2211

}

2212

2213

private static int getDropAction(DragDropEffects effects, int keyState)

2214

{

2215

int ret = java.awt.dnd.DnDConstants.ACTION_NONE;

2216

const int MK_CONTROL = 0x8;

2217

const int MK_SHIFT = 0x4;

2218

// const int WM_MOUSEWHEEL = 0x20A;

2219

// const int MK_LBUTTON = 0x1;

2220

// const int MK_MBUTTON = 0x10;

2221

// const int MK_RBUTTON = 0x2;

2222

// const int MK_XBUTTON1 = 0x20;

2223

// const int MK_XBUTTON2 = 0x40;

2224

switch (keyState & (MK_CONTROL | MK_SHIFT))

2225

{

2226

case MK_CONTROL:

2227

if ((effects & DragDropEffects.Copy) == DragDropEffects.Copy)

2228

ret = java.awt.dnd.DnDConstants.ACTION_COPY;

2229

else

2230

ret = java.awt.dnd.DnDConstants.ACTION_NONE;

2231

break;

2232

2233

case MK_CONTROL | MK_SHIFT:

2234

if ((effects & DragDropEffects.Link) == DragDropEffects.Link)

2235

ret = java.awt.dnd.DnDConstants.ACTION_LINK;

2236

else

2237

ret = java.awt.dnd.DnDConstants.ACTION_NONE;

2238

break;

2239

2240

case MK_SHIFT:

2241

if ((effects & DragDropEffects.Move) == DragDropEffects.Move)

2242

ret = java.awt.dnd.DnDConstants.ACTION_MOVE;

2243

else

2244

ret = java.awt.dnd.DnDConstants.ACTION_NONE;

2245

break;

2246

2247

default:

2248

if ((effects & DragDropEffects.Move) == DragDropEffects.Move)

2249

{

2250

ret = java.awt.dnd.DnDConstants.ACTION_MOVE;

2251

}

2252

else if ((effects & DragDropEffects.Copy) == DragDropEffects.Copy)

2253

{

2254

ret = java.awt.dnd.DnDConstants.ACTION_COPY;

2255

}

2256

else if ((effects & DragDropEffects.Link) == DragDropEffects.Link)

2257

{

2258

ret = java.awt.dnd.DnDConstants.ACTION_LINK;

2259

}

2260

break;

2261

}

2262

2263

return ret;

2264

}

2265

2266

private void OnKeyUp(object sender, KeyEventArgs e)

2267

{

2268

long when = java.lang.System.currentTimeMillis();

2269

int modifiers = GetModifiers(e.Modifiers);

2270

int keyCode = MapKeyCode(e.KeyCode);

2271

// TODO set keyChar

2272

char keyChar = ' ';

2273

int keyLocation = java.awt.@event.KeyEvent.KEY_LOCATION_STANDARD;

2274

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2275

postEvent(new java.awt.@event.KeyEvent(target, java.awt.@event.KeyEvent.KEY_RELEASED, when, modifiers, keyCode, keyChar, keyLocation));

2276

}));

2277

}

2278

2279

protected virtual void OnKeyPress(object sender, KeyPressEventArgs e)

2280

{

2281

long when = java.lang.System.currentTimeMillis();

2282

int modifiers = GetModifiers(Control.ModifierKeys);

2283

int keyCode = java.awt.@event.KeyEvent.VK_UNDEFINED;

2284

char keyChar = e.KeyChar;

2285

int keyLocation = java.awt.@event.KeyEvent.KEY_LOCATION_UNKNOWN;

2286

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2287

postEvent(new java.awt.@event.KeyEvent(target, java.awt.@event.KeyEvent.KEY_TYPED, when, modifiers, keyCode, keyChar, keyLocation));

2288

}));

2289

}

2290

2291

private void postMouseEvent(MouseEventArgs ev, int id, int clicks)

2292

{

2293

long when = java.lang.System.currentTimeMillis();

2294

int modifiers = GetMouseEventModifiers(ev);

2295

int button = GetButton(ev);

2296

int clickCount = clicks;

2297

int x = ev.X + getInsetsLeft(); //The Inset correctur is needed for Window and extended classes

2298

int y = ev.Y + getInsetsTop();

2299

bool isPopup = isPopupMenu;

2300

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2301

postEvent(new java.awt.@event.MouseEvent(target, id, when, modifiers, x, y, clickCount, isPopup, button));

2302

}));

2303

isPopupMenu = false;

2304

}

2305

2306

private void postMouseEvent(EventArgs ev, int id)

2307

{

2308

long when = java.lang.System.currentTimeMillis();

2309

int modifiers = GetModifiers(Control.ModifierKeys);

2310

int button = 0;

2311

int clickCount = 0;

2312

int x = Control.MousePosition.X - control.Location.X;

2313

int y = Control.MousePosition.Y - control.Location.Y;

2314

bool isPopup = isPopupMenu;

2315

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2316

postEvent(new java.awt.@event.MouseEvent(target, id, when, modifiers, x, y, clickCount, isPopup, button));

2317

}));

2318

isPopupMenu = false;

2319

}

2320

2321

private void postMouseWheelEvent(EventArgs ev, int id, int delta)

2322

{

2323

long when = java.lang.System.currentTimeMillis();

2324

int modifiers = GetModifiers(Control.ModifierKeys);

2325

int scrollAmount = -delta * SystemInformation.MouseWheelScrollLines / 120;

2326

int clickCount = 0;

2327

int x = Control.MousePosition.X - control.Location.X;

2328

int y = Control.MousePosition.Y - control.Location.Y;

2329

bool isPopup = isPopupMenu;

2330

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate

2331

{

2332

postEvent(new java.awt.@event.MouseWheelEvent(target, id, when, modifiers, x, y, clickCount, isPopup, java.awt.@event.MouseWheelEvent.WHEEL_UNIT_SCROLL, scrollAmount, scrollAmount));

2333

}));

2334

}

2335

2336

protected virtual void OnMouseMove(object sender, MouseEventArgs ev)

2337

{

2338

if((ev.Button & (MouseButtons.Left | MouseButtons.Right)) != 0)

2339

{

2340

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_DRAGGED, ev.Clicks);

2341

}

2342

else

2343

{

2344

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_MOVED, ev.Clicks);

2345

}

2346

}

2347

2348

protected virtual void OnMouseDown(object sender, MouseEventArgs ev)

2349

{

2350

isMouseClick = false;

2351

isDoubleClick = false;

2352

isPopupMenu = false;

2353

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_PRESSED, ev.Clicks);

2354

}

2355

2356

private void OnMouseWheel(object sender, MouseEventArgs ev)

2357

{

2358

postMouseWheelEvent(ev, java.awt.@event.MouseEvent.MOUSE_WHEEL, ev.Delta);

2359

}

2360

2361

private void OnClick(object sender, EventArgs ev)

2362

{

2363

isMouseClick = true;

2364

}

2365

2366

private void OnDoubleClick(object sender, EventArgs ev)

2367

{

2368

isDoubleClick = true;

2369

}

2370

2371

private void OnMouseUp(object sender, MouseEventArgs ev)

2372

{

2373

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_RELEASED, ev.Clicks);

2374

if (isMouseClick || isDoubleClick) // there can only be an Click OR an DoubleClick event - both count as click here

2375

{

2376

//We make our own mouse click event because the event order is different in .NET

2377

//in .NET the click occured before MouseUp

2378

int clicks = ev.Clicks;

2379

if (isDoubleClick)

2380

{

2381

clicks = 2;

2382

}

2383

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_CLICKED, clicks);

2384

}

2385

isMouseClick = false;

2386

}

2387

2388

private void OnMouseEnter(object sender, EventArgs ev)

2389

{

2390

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_ENTERED);

2391

}

2392

2393

private void OnMouseLeave(object sender, EventArgs ev)

2394

{

2395

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_EXITED);

2396

}

2397

2398

private void OnGotFocus(object sender, EventArgs e)

2399

{

2400

if (sm_suppressFocusAndActivation)

2401

{

2402

return;

2403

}

2404

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2405

postEvent(new java.awt.@event.FocusEvent(target, java.awt.@event.FocusEvent.FOCUS_GAINED));

2406

}));

2407

}

2408

2409

private void OnLostFocus(object sender, EventArgs e)

2410

{

2411

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate {

2412

postEvent(new java.awt.@event.FocusEvent(target, java.awt.@event.FocusEvent.FOCUS_LOST));

2413

}));

2414

}

2415

2416

2417

* Called from native code (on Toolkit thread) in order to

2418

* dynamically layout the Container during resizing

2419

2420

internal void dynamicallyLayoutContainer() {

2421

// If we got the WM_SIZING, this must be a Container, right?

2422

// In fact, it must be the top-level Container.

2423

//if (log.isLoggable(Level.FINE)) {

2424

// java.awt.Container parent = NetToolkit.getNativeContainer((java.awt.Component)target);

2425

// if (parent != null) {

2426

// log.log(Level.FINE, "Assertion (parent == null) failed");

2427

// }

2428

//}

2429

java.awt.Container cont = (java.awt.Container)(object)target;

2430

2431

NetToolkit.executeOnEventHandlerThread(cont, Delegates.toRunnable(delegate {

2432

// Discarding old paint events doesn't seem to be necessary.

2433

cont.invalidate();

2434

cont.validate();

2435

2436

//if (surfaceData instanceof OGLSurfaceData) {

2437

// // 6290245: When OGL is enabled, it is necessary to

2438

// // replace the SurfaceData for each dynamic layout

2439

// // request so that the OGL viewport stays in sync

2440

// // with the window bounds.

2441

// try {

2442

// replaceSurfaceData();

2443

// } catch (InvalidPipeException e) {

2444

// // REMIND: this is unlikely to occur for OGL, but

2445

// // what do we do if surface creation fails?

2446

// }

2447

//}

2448

2449

// Forcing a paint here doesn't seem to be necessary.

2450

// paintDamagedAreaImmediately();

2451

}));

2452

}

2453

2454

2455

* Paints any portion of the component that needs updating

2456

* before the call returns (similar to the Win32 API UpdateWindow)

2457

2458

internal void paintDamagedAreaImmediately()

2459

{

2460

// force Windows to send any pending WM_PAINT events so

2461

// the damage area is updated on the Java side

2462

updateWindow();

2463

// make sure paint events are transferred to main event queue

2464

// for coalescing

2465

NetToolkit.flushPendingEvents();

2466

// paint the damaged area

2467

paintArea.paint(target, shouldClearRectBeforePaint());

2468

}

2469

2470

private void updateWindow()

2471

{

2472

NetToolkit.BeginInvoke(delegate

2473

{

2474

control.Update();

2475

});

2476

}

2477

2478

/* override and return false on components that DO NOT require

2479

a clearRect() before painting (i.e. native components) */

2480

public virtual bool shouldClearRectBeforePaint()

2481

{

2482

return true;

2483

}

2484

2485

private void OnPopupMenu(object sender, EventArgs ev)

2486

{

2487

isPopupMenu = true;

2488

}

2489

2490

2491

* Post an event. Queue it for execution by the callback thread.

2492

2493

internal void postEvent(java.awt.AWTEvent evt)

2494

{

2495

NetToolkit.postEvent(NetToolkit.targetToAppContext(target), evt);

2496

}

2497

2498

// Routines to support deferred window positioning.

2499

public void beginLayout()

2500

{

2501

// Skip all painting till endLayout

2502

isLayouting = true;

2503

}

2504

2505

public void endLayout()

2506

{

2507

if (!paintArea.isEmpty() && !paintPending &&

2508

!target.getIgnoreRepaint())

2509

{

2510

// if not waiting for native painting repaint damaged area

2511

postEvent(new java.awt.@event.PaintEvent(target, java.awt.@event.PaintEvent.PAINT, new java.awt.Rectangle()));

2512

}

2513

isLayouting = false;

2514

}

2515

2516

public void beginValidate()

2517

{

2518

// Invoke(delegate

2519

// {

2520

// if (m_validationNestCount == 0)

2521

// {

2522

// m_hdwp = BeginDeferWindowPos();

2523

// }

2524

// m_validationNestCount++;

2525

// });

2526

}

2527

2528

public void endValidate()

2529

{

2530

// Invoke(delegate

2531

// {

2532

// m_validationNestCount--;

2533

// if (m_validationNestCount == 0) {

2534

// // if this call to EndValidate is not nested inside another

2535

// // Begin/EndValidate pair, end deferred window positioning

2536

// ::EndDeferWindowPos(m_hdwp);

2537

// m_hdwp = NULL;

2538

// }

2539

// });

2540

}

2541

2542

// Returns true if we are inside begin/endLayout and

2543

// are waiting for native painting

2544

public bool isPaintPending()

2545

{

2546

return paintPending && isLayouting;

2547

}

2548

2549

public override int checkImage(java.awt.Image img, int width, int height, java.awt.image.ImageObserver ob)

2550

{

2551

return getToolkit().checkImage(img, width, height, ob);

2552

}

2553

2554

public override java.awt.Image createImage(java.awt.image.ImageProducer prod)

2555

{

2556

return new sun.awt.image.ToolkitImage(prod);

2557

}

2558

2559

public override java.awt.Image createImage(int width, int height)

2560

{

2561

return new java.awt.image.BufferedImage(width, height, java.awt.image.BufferedImage.TYPE_INT_ARGB);

2562

}

2563

2564

public override void disable()

2565

{

2566

NetToolkit.BeginInvoke(delegate { Enable( false ); });

2567

}

2568

2569

public override void dispose()

2570

{

2571

bool callDisposed = true;

2572

lock(this)

2573

{

2574

if (disposed)

2575

callDisposed = false;

2576

disposed = true;

2577

}

2578

if (callDisposed)

2579

{

2580

disposeImpl();

2581

}

2582

}

2583

2584

protected virtual void disposeImpl()

2585

{

2586

NetToolkit.targetDisposedPeer(target, this);

2587

NetToolkit.Invoke(nativeDispose);

2588

}

2589

2590

protected virtual void nativeDispose()

2591

{

2592

unhookEvents();

2593

control.Dispose();

2594

}

2595

2596

public override void enable()

2597

{

2598

NetToolkit.BeginInvoke(delegate { Enable(true); });

2599

}

2600

2601

public override java.awt.image.ColorModel getColorModel()

2602

{

2603

//we return the default ColorModel because this causes the least problems with conversions

2604

return java.awt.image.ColorModel.getRGBdefault();

2605

}

2606

2607

public override java.awt.FontMetrics getFontMetrics(java.awt.Font f)

2608

{

2609

return sun.font.FontDesignMetrics.getMetrics(f);

2610

}

2611

2612

public override java.awt.Graphics getGraphics()

2613

{

2614

if (!control.IsDisposed)

2615

{

2616

/* Fix for bug 4746122. Color and Font shouldn't be null */

2617

java.awt.Color bgColor = background;

2618

if (bgColor == null)

2619

{

2620

bgColor = java.awt.SystemColor.window;

2621

}

2622

java.awt.Color fgColor = foreground;

2623

if (fgColor == null)

2624

{

2625

fgColor = java.awt.SystemColor.windowText;

2626

}

2627

java.awt.Font font = this.font;

2628

if (font == null)

2629

{

2630

font = defaultFont;

2631

}

2632

return new ComponentGraphics(this.control, fgColor, bgColor, font);

2633

}

2634

return null;

2635

}

2636

2637

public override java.awt.Point getLocationOnScreen()

2638

{

2639

return NetToolkit.Invoke<java.awt.Point>(delegate

2640

{

2641

Point p = new Point();

2642

p = control.PointToScreen(p);

2643

return new java.awt.Point(p.X, p.Y);

2644

});

2645

}

2646

2647

public override java.awt.Dimension getMinimumSize()

2648

{

2649

return target.getSize();

2650

}

2651

2652

public override java.awt.Dimension getPreferredSize()

2653

{

2654

return getMinimumSize();

2655

}

2656

2657

public override java.awt.Toolkit getToolkit()

2658

{

2659

return java.awt.Toolkit.getDefaultToolkit();

2660

}

2661

2662

// returns true if the event has been handled and shouldn't be propagated

2663

// though handleEvent method chain - e.g. WTextFieldPeer returns true

2664

// on handling '\n' to prevent it from being passed to native code

2665

public virtual bool handleJavaKeyEvent(java.awt.@event.KeyEvent e) { return false; }

2666

2667

private void nativeHandleEvent(java.awt.AWTEvent e)

2668

{

2669

// TODO arrghh!! code from void AwtComponent::_NativeHandleEvent(void *param) in awt_Component.cpp should be here

2670

}

2671

2672

public override void handleEvent(java.awt.AWTEvent e)

2673

{

2674

int id = e.getID();

2675

2676

if (((java.awt.Component)target).isEnabled() && (e is java.awt.@event.KeyEvent) && !((java.awt.@event.KeyEvent)e).isConsumed())

2677

{

2678

if (handleJavaKeyEvent((java.awt.@event.KeyEvent)e))

2679

{

2680

return;

2681

}

2682

}

2683

2684

switch (id)

2685

{

2686

case java.awt.@event.PaintEvent.PAINT:

2687

// Got native painting

2688

paintPending = false;

2689

// Fallthrough to next statement

2690

goto case java.awt.@event.PaintEvent.UPDATE;

2691

case java.awt.@event.PaintEvent.UPDATE:

2692

// Skip all painting while layouting and all UPDATEs

2693

// while waiting for native paint

2694

if (!isLayouting && !paintPending)

2695

{

2696

paintArea.paint(target, shouldClearRectBeforePaint());

2697

}

2698

return;

2699

default:

2700

break;

2701

}

2702

2703

// Call the native code

2704

nativeHandleEvent(e);

2705

}

2706

2707

public override void hide()

2708

{

2709

NetToolkit.BeginInvoke(delegate { control.Visible = false; });

2710

}

2711

2712

public bool isFocusTraversable()

2713

{

2714

return true;

2715

}

2716

2717

public override java.awt.Dimension minimumSize()

2718

{

2719

return getMinimumSize();

2720

}

2721

2722

public override java.awt.Dimension preferredSize()

2723

{

2724

return getPreferredSize();

2725

}

2726

2727

public override void paint(java.awt.Graphics graphics)

2728

{

2729

target.paint(graphics);

2730

}

2731

2732

public override bool prepareImage(java.awt.Image img, int width, int height, java.awt.image.ImageObserver ob)

2733

{

2734

return getToolkit().prepareImage(img, width, height, ob);

2735

}

2736

2737

public override void print(java.awt.Graphics graphics)

2738

{

2739

throw new NotImplementedException();

2740

}

2741

2742

public override void repaint(long tm, int x, int y, int width, int height)

2743

{

2744

}

2745

2746

public void requestFocus()

2747

{

2748

NetToolkit.Invoke<bool>(control.Focus);

2749

}

2750

2751

/// <summary>

2752

///

2753

/// </summary>

2754

/// <param name="request">the component for which the focus is requested</param>

2755

/// <param name="temporary">indicates if the focus change is temporary (true) or permanent (false)</param>

2756

/// <param name="allowWindowFocus">indicates if it's allowed to change window focus</param>

2757

/// <param name="time">the timestamp</param>

2758

/// <returns></returns>

2759

public bool requestFocus(java.awt.Component request, bool temporary, bool allowWindowFocus, long time)

2760

{

2761

if (!getEnabled() || !getVisible())

2762

{

2763

return false;

2764

}

2765

postEvent(new java.awt.@event.FocusEvent(request, java.awt.@event.FocusEvent.FOCUS_GAINED, temporary, target));

2766

return true;

2767

}

2768

2769

public override void reshape(int x, int y, int width, int height)

2770

{

2771

NetToolkit.BeginInvoke(delegate

2772

{

2773

Form window = control.FindForm();

2774

java.awt.Insets insets;

2775

if (window is MyForm)

2776

{

2777

insets = ((MyForm)window).peerInsets;

2778

}

2779

else

2780

{

2781

insets = new java.awt.Insets(0, 0, 0, 0);

2782

}

2783

control.SetBounds(x - insets.left, y - insets.top, width, height);

2784

//If the .NET control does not accept the new bounds (minimum size, maximum size)

2785

//then we need to reflect the real bounds on the .NET site to the Java site

2786

Rectangle bounds = control.Bounds;

2787

if (bounds.X + insets.left != x || bounds.Y + insets.top != y)

2788

{

2789

AWTAccessor.getComponentAccessor().setLocation(target, bounds.X + insets.left, bounds.Y + insets.top);

2790

}

2791

if (bounds.Width != width || bounds.Height != height)

2792

{

2793

AWTAccessor.getComponentAccessor().setSize(target, bounds.Width, bounds.Height);

2794

}

2795

});

2796

}

2797

2798

public override void setBackground(java.awt.Color color)

2799

{

2800

lock (this)

2801

{

2802

this.background = color;

2803

NetToolkit.BeginInvoke(delegate { control.BackColor = J2C.ConvertColor(color); });

2804

}

2805

}

2806

2807

private void reshapeNoCheck(int x, int y, int width, int height)

2808

{

2809

NetToolkit.BeginInvoke(delegate { control.SetBounds(x, y, width, height); });

2810

}

2811

2812

public override void setBounds(int x, int y, int width, int height, int op)

2813

{

2814

// Should set paintPending before reahape to prevent

2815

// thread race between paint events

2816

// Native components do redraw after resize

2817

paintPending = (width != oldWidth) || (height != oldHeight);

2818

2819

if ((op & java.awt.peer.ComponentPeer.__Fields.NO_EMBEDDED_CHECK) != 0)

2820

{

2821

reshapeNoCheck(x, y, width, height);

2822

}

2823

else

2824

{

2825

reshape(x, y, width, height);

2826

}

2827

if ((width != oldWidth) || (height != oldHeight))

2828

{

2829

// Only recreate surfaceData if this setBounds is called

2830

// for a resize; a simple move should not trigger a recreation

2831

try

2832

{

2833

//replaceSurfaceData();

2834

}

2835

catch (sun.java2d.InvalidPipeException)

2836

{

2837

// REMIND : what do we do if our surface creation failed?

2838

}

2839

oldWidth = width;

2840

oldHeight = height;

2841

}

2842

2843

serialNum++;

2844

}

2845

2846

private void setCursorImpl(java.awt.Cursor cursor)

2847

{

2848

if (cursor is NetCustomCursor)

2849

{

2850

NetCustomCursor ncc = (NetCustomCursor)cursor;

2851

control.Cursor = ncc.Cursor;

2852

return;

2853

}

2854

switch(cursor.getType())

2855

{

2856

case java.awt.Cursor.WAIT_CURSOR:

2857

control.Cursor = Cursors.WaitCursor;

2858

break;

2859

case java.awt.Cursor.DEFAULT_CURSOR:

2860

control.Cursor = Cursors.Default;

2861

break;

2862

case java.awt.Cursor.HAND_CURSOR:

2863

control.Cursor = Cursors.Hand;

2864

break;

2865

case java.awt.Cursor.CROSSHAIR_CURSOR:

2866

control.Cursor = Cursors.Cross;

2867

break;

2868

case java.awt.Cursor.W_RESIZE_CURSOR:

2869

case java.awt.Cursor.E_RESIZE_CURSOR:

2870

control.Cursor = Cursors.SizeWE;

2871

break;

2872

case java.awt.Cursor.MOVE_CURSOR:

2873

control.Cursor = Cursors.SizeAll;

2874

break;

2875

case java.awt.Cursor.N_RESIZE_CURSOR:

2876

case java.awt.Cursor.S_RESIZE_CURSOR:

2877

control.Cursor = Cursors.SizeNS;

2878

break;

2879

case java.awt.Cursor.NE_RESIZE_CURSOR:

2880

case java.awt.Cursor.SW_RESIZE_CURSOR:

2881

control.Cursor = Cursors.SizeNESW;

2882

break;

2883

case java.awt.Cursor.NW_RESIZE_CURSOR:

2884

case java.awt.Cursor.SE_RESIZE_CURSOR:

2885

control.Cursor = Cursors.SizeNWSE;

2886

break;

2887

case java.awt.Cursor.TEXT_CURSOR:

2888

control.Cursor = Cursors.IBeam;

2889

break;

2890

default:

2891

Console.WriteLine("setCursor not implement for: " + cursor);

2892

break;

2893

}

2894

}

2895

2896

public void setCursor(java.awt.Cursor cursor)

2897

{

2898

NetToolkit.Invoke(setCursorImpl, cursor);

2899

}

2900

2901

public bool getEnabled()

2902

{

2903

return NetToolkit.Invoke<bool>(delegate { return control.Enabled; });

2904

}

2905

2906

public bool getFocused()

2907

{

2908

return NetToolkit.Invoke<bool>(delegate { return control.Focused; });

2909

}

2910

2911

public bool getVisible()

2912

{

2913

return NetToolkit.Invoke<bool>(delegate { return control.Visible; });

2914

}

2915

2916

public override void setEnabled(bool enabled)

2917

{

2918

if (enabled)

2919

{

2920

enable();

2921

}

2922

else

2923

{

2924

disable();

2925

}

2926

}

2927

2928

public override void setFont(java.awt.Font font)

2929

{

2930

lock (this)

2931

{

2932

this.font = font;

2933

NetToolkit.BeginInvoke(delegate { control.Font = font.getNetFont(); });

2934

}

2935

}

2936

2937

public override void setForeground(java.awt.Color color)

2938

{

2939

lock (this)

2940

{

2941

this.foreground = color;

2942

NetToolkit.BeginInvoke(delegate { control.ForeColor = J2C.ConvertColor(color); });

2943

}

2944

}

2945

2946

public override void setVisible(bool visible)

2947

{

2948

if (visible)

2949

{

2950

show();

2951

}

2952

else

2953

{

2954

hide();

2955

}

2956

}

2957

2958

public override void show()

2959

{

2960

java.awt.Dimension s = target.getSize();

2961

oldHeight = s.height;

2962

oldWidth = s.width;

2963

pShow();

2964

}

2965

2966

2967

* Return the GraphicsConfiguration associated with this peer, either

2968

* the locally stored winGraphicsConfig, or that of the target Component.

2969

2970

public override java.awt.GraphicsConfiguration getGraphicsConfiguration()

2971

{

2972

// we don't need a treelock here, since

2973

// Component.getGraphicsConfiguration() gets it itself.

2974

return target.getGraphicsConfiguration();

2975

}

2976

2977

public void setEventMask (long mask)

2978

{

2979

//Console.WriteLine("NOTE: NetComponentPeer.setEventMask not implemented");

2980

}

2981

2982

public override bool isObscured()

2983

{

2984

// should never be called because we return false from canDetermineObscurity()

2985

return true;

2986

}

2987

2988

public override bool canDetermineObscurity()

2989

{

2990

// JDK returns true here and uses GetClipBox to determine if the window is partially obscured,

2991

// this is an optimization for scrolling in javax.swing.JViewport, since there appears to be

2992

// no managed equivalent of GetClipBox, we'll simply return false and forgo the optimization.

2993

return false;

2994

}

2995

2996

public override void coalescePaintEvent(java.awt.@event.PaintEvent e)

2997

{

2998

java.awt.Rectangle r = e.getUpdateRect();

2999

if (!(e is sun.awt.@event.IgnorePaintEvent))

3000

{

3001

paintArea.add(r, e.getID());

3002

}

3003

}

3004

3005

public override void updateCursorImmediately()

3006

{

3007

}

3008

3009

public override java.awt.image.VolatileImage createVolatileImage(int width, int height)

3010

{

3011

return new NetVolatileImage(target, width, height);

3012

}

3013

3014

public override bool handlesWheelScrolling()

3015

{

3016

return true;

3017

}

3018

3019

public override void createBuffers(int x, java.awt.BufferCapabilities capabilities)

3020

{

3021

throw new NotImplementedException();

3022

}

3023

3024

public override java.awt.Image getBackBuffer()

3025

{

3026

throw new NotImplementedException();

3027

}

3028

3029

public override void flip(java.awt.BufferCapabilities.FlipContents contents)

3030

{

3031

throw new NotImplementedException();

3032

}

3033

3034

public override void destroyBuffers()

3035

{

3036

throw new NotImplementedException();

3037

}

3038

3039

public override bool isFocusable()

3040

{

3041

return false;

3042

}

3043

3044

protected bool isDisposed()

3045

{

3046

return disposed;

3047

}

3048

3049

public override java.awt.Rectangle getBounds()

3050

{

3051

return target.getBounds();

3052

}

3053

3054

public override void reparent(java.awt.peer.ContainerPeer parent)

3055

{

3056

throw new NotImplementedException();

3057

}

3058

3059

public override bool isReparentSupported()

3060

{

3061

return false;

3062

}

3063

3064

// Do nothing for heavyweight implementation

3065

public override void layout()

3066

{

3067

}

3068

3069

public override void applyShape(sun.java2d.pipe.Region shape)

3070

{

3071

NetToolkit.BeginInvoke(ApplyShapeImpl, shape);

3072

}

3073

3074

private void ApplyShapeImpl(sun.java2d.pipe.Region shape)

3075

{

3076

control.Region = J2C.ConvertRegion(shape);

3077

}

3078

3079

//copied form KeyboardFocusManager

3080

private const int SNFH_FAILURE = 0;

3081

private const int SNFH_SUCCESS_HANDLED = 1;

3082

private const int SNFH_SUCCESS_PROCEED = 2;

3083

3084

private static java.lang.reflect.Method shouldNativelyFocusHeavyweight;

3085

private static java.lang.reflect.Method processSynchronousLightweightTransfer;

3086

private static java.lang.reflect.Method removeLastFocusRequest;

3087

3088

public override bool requestFocus(java.awt.Component lightweightChild, bool temporary, bool focusedWindowChangeAllowed, long time, sun.awt.CausedFocusEvent.Cause cause)

3089

{

3090

// this is a interpretation of the code in WComponentPeer.java and awt_component.cpp

3091

try

3092

{

3093

if (processSynchronousLightweightTransfer == null)

3094

{

3095

java.security.AccessController.doPrivileged(Delegates.toPrivilegedAction(delegate

3096

{

3097

java.lang.Class keyboardFocusManagerCls = typeof(java.awt.KeyboardFocusManager);

3098

java.lang.reflect.Method method = keyboardFocusManagerCls.getDeclaredMethod(

3099

"processSynchronousLightweightTransfer",

3100

typeof(java.awt.Component),

3101

typeof(java.awt.Component),

3102

java.lang.Boolean.TYPE,

3103

java.lang.Boolean.TYPE,

3104

java.lang.Long.TYPE);

3105

method.setAccessible(true);

3106

processSynchronousLightweightTransfer = method;

3107

return null;

3108

}));

3109

}

3110

processSynchronousLightweightTransfer.invoke(

3111

null,

3112

target,

3113

lightweightChild,

3114

java.lang.Boolean.valueOf(temporary),

3115

java.lang.Boolean.valueOf(focusedWindowChangeAllowed),

3116

java.lang.Long.valueOf(time));

3117

}

3118

catch

3119

{

3120

return true;

3121

}

3122

if (shouldNativelyFocusHeavyweight == null)

3123

{

3124

java.security.AccessController.doPrivileged(Delegates.toPrivilegedAction(delegate

3125

{

3126

java.lang.Class keyboardFocusManagerCls = typeof(java.awt.KeyboardFocusManager);

3127

java.lang.reflect.Method method = keyboardFocusManagerCls.getDeclaredMethod(

3128

"shouldNativelyFocusHeavyweight",

3129

typeof(java.awt.Component),

3130

typeof(java.awt.Component),

3131

java.lang.Boolean.TYPE,

3132

java.lang.Boolean.TYPE,

3133

java.lang.Long.TYPE,

3134

typeof(sun.awt.CausedFocusEvent.Cause));

3135

method.setAccessible(true);

3136

shouldNativelyFocusHeavyweight = method;

3137

return null;

3138

}));

3139

}

3140

int retval = ((java.lang.Integer)shouldNativelyFocusHeavyweight.invoke(

3141

null,

3142

target,

3143

lightweightChild,

3144

java.lang.Boolean.valueOf(temporary),

3145

java.lang.Boolean.valueOf(focusedWindowChangeAllowed),

3146

java.lang.Long.valueOf(time),

3147

cause)).intValue();

3148

if (retval == SNFH_SUCCESS_HANDLED)

3149

{

3150

return true;

3151

}

3152

else if (retval == SNFH_SUCCESS_PROCEED)

3153

{

3154

if (getFocused())

3155

{

3156

return true;

3157

}

3158

if (removeLastFocusRequest == null)

3159

{

3160

java.security.AccessController.doPrivileged(Delegates.toPrivilegedAction(delegate

3161

{

3162

java.lang.Class keyboardFocusManagerCls = typeof(java.awt.KeyboardFocusManager);

3163

java.lang.reflect.Method method = keyboardFocusManagerCls.getDeclaredMethod(

3164

"removeLastFocusRequest",

3165

typeof(java.awt.Component));

3166

method.setAccessible(true);

3167

removeLastFocusRequest = method;

3168

return null;

3169

}));

3170

}

3171

removeLastFocusRequest.invoke(null, target);

3172

}

3173

//SNFH_FAILURE

3174

return false;

3175

}

3176

3177

/**

3178

* Move the back buffer to the front buffer.

3179

3180

* @param x1 the area to be flipped, upper left X coordinate

3181

* @param y1 the area to be flipped, upper left Y coordinate

3182

* @param x2 the area to be flipped, lower right X coordinate

3183

* @param y2 the area to be flipped, lower right Y coordinate

3184

* @param flipAction the flip action to perform

3185

3186

* @see Component.FlipBufferStrategy#flip

3187

3188

public override void flip(int x1, int y1, int x2, int y2, java.awt.BufferCapabilities.FlipContents flipAction)

3189

{

3190

throw new ikvm.@internal.NotYetImplementedError();

3191

}

3192

3193

/**

3194

* Lowers this component at the bottom of the above HW peer. If the above parameter

3195

* is null then the method places this component at the top of the Z-order.

3196

3197

public override void setZOrder(java.awt.peer.ComponentPeer above)

3198

{

3199

Control.ControlCollection controls = control.Controls;

3200

if (!controls.Contains(control))

3201

{

3202

// Control was not added to any window. Occur if you call addNotify without

3203

return;

3204

}

3205

if (above == null)

3206

{

3207

controls.SetChildIndex(control, 0);

3208

}

3209

else

3210

{

3211

NetComponentPeer<T, C> netPeer = (NetComponentPeer<T, C>)above;

3212

controls.SetChildIndex(control, controls.GetChildIndex(netPeer.control));

3213

}

3214

}

3215

3216

/**

3217

* Updates internal data structures related to the component's GC.

3218

3219

* @return if the peer needs to be recreated for the changes to take effect

3220

* @since 1.7

3221

3222

public override bool updateGraphicsData(java.awt.GraphicsConfiguration gc)

3223

{

3224

throw new ikvm.@internal.NotYetImplementedError();

3225

}

3226

3227

}

3228

3229

sealed class NetScrollbarPeer : NetComponentPeer<java.awt.Scrollbar, ScrollBar>, java.awt.peer.ScrollbarPeer

3230

{

3231

internal NetScrollbarPeer(java.awt.Scrollbar target)

3232

: base(target)

3233

{

3234

}

3235

3236

public void setLineIncrement(int i)

3237

{

3238

}

3239

3240

public void setPageIncrement(int i)

3241

{

3242

}

3243

3244

public void setValues(int i1, int i2, int i3, int i4)

3245

{

3246

}

3247

3248

protected override ScrollBar CreateControl()

3249

{

3250

switch (target.getOrientation())

3251

{

3252

case java.awt.Scrollbar.VERTICAL:

3253

return new VScrollBar();

3254

default:

3255

return new HScrollBar();

3256

}

3257

}

3258

}

3259

3260

sealed class NetScrollPanePeer : NetComponentPeer<java.awt.ScrollPane, ScrollableControl>, java.awt.peer.ScrollPanePeer

3261

{

3262

internal NetScrollPanePeer(java.awt.ScrollPane pane)

3263

: base(pane)

3264

{

3265

}

3266

3267

public void childResized(int i1, int i2)

3268

{

3269

}

3270

3271

public int getHScrollbarHeight()

3272

{

3273

return NetToolkit.Invoke<int>(delegate { return 0; });

3274

}

3275

3276

public int getVScrollbarWidth()

3277

{

3278

return NetToolkit.Invoke<int>(delegate { return 0; });

3279

}

3280

3281

public void setScrollPosition(int i1, int i2)

3282

{

3283

}

3284

3285

public void setUnitIncrement(java.awt.Adjustable a, int i)

3286

{

3287

}

3288

3289

public void setValue(java.awt.Adjustable a, int i)

3290

{

3291

}

3292

3293

public java.awt.Insets getInsets()

3294

{

3295

return NetToolkit.Invoke<java.awt.Insets>(delegate { return new java.awt.Insets(0, 0, 0, 0); });

3296

}

3297

3298

public java.awt.Insets insets()

3299

{

3300

return getInsets();

3301

}

3302

3303

public bool isRestackSupported()

3304

{

3305

return false;

3306

}

3307

3308

public void restack()

3309

{

3310

throw new NotImplementedException();

3311

}

3312

3313

protected override ScrollableControl CreateControl()

3314

{

3315

return new ScrollableControl();

3316

}

3317

}

3318

3319

sealed class NetButtonPeer : NetComponentPeer<java.awt.Button, Button>, java.awt.peer.ButtonPeer

3320

{

3321

public NetButtonPeer(java.awt.Button awtbutton)

3322

: base(awtbutton)

3323

{

3324

if (!awtbutton.isBackgroundSet())

3325

{

3326

awtbutton.setBackground(java.awt.SystemColor.control);

3327

}

3328

control.BackColor = Color.FromArgb(awtbutton.getBackground().getRGB());

3329

control.Text = awtbutton.getLabel();

3330

control.Click += new EventHandler(OnClick);

3331

}

3332

3333

private void OnClick(object sender, EventArgs e)

3334

{

3335

// TODO set all these properties correctly

3336

string cmd = "";

3337

long when = 0;

3338

int modifiers = 0;

3339

postEvent(new java.awt.@event.ActionEvent(target, java.awt.@event.ActionEvent.ACTION_PERFORMED, cmd, when, modifiers));

3340

}

3341

3342

public void setLabel(string label)

3343

{

3344

NetToolkit.Invoke(delegate { control.Text = label; });

3345

}

3346

3347

public override java.awt.Dimension getMinimumSize()

3348

{

3349

using(Graphics g = control.CreateGraphics())

3350

{

3351

// TODO get these fudge factors from somewhere

3352

return new java.awt.Dimension((int)Math.Round(12 + g.MeasureString(control.Text, control.Font).Width) * 8 / 7, 6 + control.Font.Height * 8 / 7);

3353

}

3354

}

3355

3356

public override bool shouldClearRectBeforePaint()

3357

{

3358

return false;

3359

}

3360

3361

protected override Button CreateControl()

3362

{

3363

return new Button();

3364

}

3365

}

3366

3367

abstract class NetTextComponentPeer<T> : NetComponentPeer<T, TextBox>, java.awt.peer.TextComponentPeer

3368

where T : java.awt.TextComponent

3369

{

3370

public NetTextComponentPeer(java.awt.TextComponent textComponent)

3371

: base((T)textComponent)

3372

{

3373

#if __MonoCS__

3374

// MONOBUG mcs generates a ldflda on a readonly field, so we use a temp

3375

T target = this.target;

3376

#endif

3377

if (!target.isBackgroundSet())

3378

{

3379

target.setBackground(java.awt.SystemColor.window);

3380

}

3381

setBackground(target.getBackground());

3382

control.AutoSize = false;

3383

control.Text = target.getText();

3384

}

3385

3386

public override bool isFocusable()

3387

{

3388

return true;

3389

}

3390

3391

protected override void OnKeyPress(object sender, KeyPressEventArgs e)

3392

{

3393

base.OnKeyPress(sender, e);

3394

// TODO for TextAreas this probably isn't the right behaviour

3395

if(e.KeyChar == '\r')

3396

{

3397

// TODO set all these properties correctly

3398

string cmd = "";

3399

long when = 0;

3400

int modifiers = 0;

3401

postEvent(new java.awt.@event.ActionEvent(target, java.awt.@event.ActionEvent.ACTION_PERFORMED, cmd, when, modifiers));

3402

}

3403

}

3404

3405

public int getSelectionEnd()

3406

{

3407

return NetToolkit.Invoke<int>(delegate { return control.SelectionStart + control.SelectionLength; });

3408

}

3409

3410

public int getSelectionStart()

3411

{

3412

return NetToolkit.Invoke<int>(delegate { return control.SelectionStart; });

3413

}

3414

3415

public string getText()

3416

{

3417

return NetToolkit.Invoke<string>(delegate { return control.Text; });

3418

}

3419

3420

public void setText(string text)

3421

{

3422

NetToolkit.Invoke(delegate { control.Text = text; });

3423

}

3424

3425

public void select(int start_pos, int end_pos)

3426

{

3427

throw new NotImplementedException();

3428

}

3429

3430

public void setEditable(bool editable)

3431

{

3432

throw new NotImplementedException();

3433

}

3434

3435

public int getCaretPosition()

3436

{

3437

return getSelectionStart();

3438

}

3439

3440

private void setCaretPositionImpl(int pos)

3441

{

3442

control.SelectionStart = pos;

3443

control.SelectionLength = 0;

3444

}

3445

3446

public void setCaretPosition(int pos)

3447

{

3448

NetToolkit.Invoke(setCaretPositionImpl, pos);

3449

}

3450

3451

public long filterEvents(long filter)

3452

{

3453

throw new NotImplementedException();

3454

}

3455

3456

public int getIndexAtPoint(int x, int y)

3457

{

3458

throw new NotImplementedException();

3459

}

3460

3461

public java.awt.Rectangle getCharacterBounds(int pos)

3462

{

3463

throw new NotImplementedException();

3464

}

3465

3466

public java.awt.im.InputMethodRequests getInputMethodRequests()

3467

{

3468

throw new NotImplementedException();

3469

}

3470

3471

protected sealed override TextBox CreateControl()

3472

{

3473

return new TextBox();

3474

}

3475

}

3476

3477

sealed class NetChoicePeer : NetComponentPeer<java.awt.Choice, RadioButton>, java.awt.peer.ChoicePeer

3478

{

3479

public NetChoicePeer(java.awt.Choice target)

3480

: base(target)

3481

{

3482

}

3483

3484

public void add(string str, int i)

3485

{

3486

// TODO: Add NetChoicePeer.add implementation

3487

}

3488

3489

public void addItem(string str, int i)

3490

{

3491

// TODO: Add NetChoicePeer.addItem implementation

3492

}

3493

3494

public void select(int i)

3495

{

3496

// TODO: Add NetChoicePeer.select implementation

3497

}

3498

3499

public void removeAll()

3500

{

3501

// TODO: Add NetChoicePeer.removeAll implementation

3502

}

3503

3504

public void remove(int i)

3505

{

3506

// TODO: Add NetChoicePeer.remove implementation

3507

}

3508

3509

protected override RadioButton CreateControl()

3510

{

3511

return new RadioButton();

3512

}

3513

}

3514

3515

sealed class NetCheckboxPeer : NetComponentPeer<java.awt.Checkbox, CheckBox>, java.awt.peer.CheckboxPeer

3516

{

3517

public NetCheckboxPeer(java.awt.Checkbox target)

3518

: base(target)

3519

{

3520

}

3521

3522

public void setCheckboxGroup(java.awt.CheckboxGroup cg)

3523

{

3524

// TODO: Add NetCheckboxPeer.setCheckboxGroup implementation

3525

}

3526

3527

public void setState(bool b)

3528

{

3529

// TODO: Add NetCheckboxPeer.setState implementation

3530

}

3531

3532

public void setLabel(string str)

3533

{

3534

// TODO: Add NetCheckboxPeer.setLabel implementation

3535

}

3536

3537

protected override CheckBox CreateControl()

3538

{

3539

return new CheckBox();

3540

}

3541

}

3542

3543

sealed class NetLabelPeer : NetComponentPeer<java.awt.Label, Label>, java.awt.peer.LabelPeer

3544

{

3545

public NetLabelPeer(java.awt.Label jlabel)

3546

: base(jlabel)

3547

{

3548

control.Text = jlabel.getText();

3549

setAlignment(jlabel.getAlignment());

3550

}

3551

3552

public void setAlignment(int align)

3553

{

3554

ContentAlignment alignment;

3555

switch(align)

3556

{

3557

case java.awt.Label.LEFT:

3558

alignment = ContentAlignment.TopLeft;

3559

break;

3560

case java.awt.Label.CENTER:

3561

alignment = ContentAlignment.TopCenter;

3562

break;

3563

case java.awt.Label.RIGHT:

3564

alignment = ContentAlignment.TopRight;

3565

break;

3566

default:

3567

return;

3568

}

3569

NetToolkit.Invoke(setAlignImpl, alignment);

3570

}

3571

3572

private void setAlignImpl(ContentAlignment alignment)

3573

{

3574

control.TextAlign = (ContentAlignment)alignment;

3575

}

3576

3577

public void setText(string s)

3578

{

3579

NetToolkit.Invoke(setTextImpl, s);

3580

}

3581

3582

private void setTextImpl(string s)

3583

{

3584

control.Text = s;

3585

}

3586

3587

public override java.awt.Dimension preferredSize()

3588

{

3589

return NetToolkit.Invoke<java.awt.Dimension>(getPreferredSizeImpl);

3590

}

3591

3592

private java.awt.Dimension getPreferredSizeImpl()

3593

{

3594

// HACK get these fudge factors from somewhere

3595

return new java.awt.Dimension(control.PreferredWidth, 2 + control.PreferredHeight);

3596

}

3597

3598

public override bool shouldClearRectBeforePaint()

3599

{

3600

// is native control, don't clear

3601

return false;

3602

}

3603

3604

protected override Label CreateControl()

3605

{

3606

return new Label();

3607

}

3608

}

3609

3610

sealed class NetTextFieldPeer : NetTextComponentPeer<java.awt.TextField>, java.awt.peer.TextFieldPeer

3611

{

3612

public NetTextFieldPeer(java.awt.TextField textField)

3613

: base(textField)

3614

{

3615

setEchoCharacterImpl(textField.getEchoChar());

3616

}

3617

3618

public java.awt.Dimension minimumSize(int len)

3619

{

3620

return getMinimumSize(len);

3621

}

3622

3623

public java.awt.Dimension preferredSize(int len)

3624

{

3625

return getPreferredSize(len);

3626

}

3627

3628

public java.awt.Dimension getMinimumSize(int len)

3629

{

3630

return getPreferredSize(len);

3631

}

3632

3633

public java.awt.Dimension getPreferredSize(int len)

3634

{

3635

// TODO use control.Invoke

3636

using(Graphics g = control.CreateGraphics())

3637

{

3638

return new java.awt.Dimension((int)Math.Round((g.MeasureString("abcdefghijklm", control.Font).Width * len) / 13), ((TextBox)control).PreferredHeight);

3639

}

3640

}

3641

3642

public void setEchoChar(char echo_char)

3643

{

3644

setEchoCharacter(echo_char);

3645

}

3646

3647

private void setEchoCharacterImpl(char echo_char)

3648

{

3649

control.PasswordChar = echo_char;

3650

}

3651

3652

public void setEchoCharacter(char echo_char)

3653

{

3654

control.Invoke(new Action<char>(setEchoCharacterImpl), echo_char);

3655

}

3656

3657

public override bool handleJavaKeyEvent(java.awt.@event.KeyEvent e)

3658

{

3659

switch (e.getID())

3660

{

3661

case java.awt.@event.KeyEvent.KEY_TYPED:

3662

if ((e.getKeyChar() == '\n') && !e.isAltDown() && !e.isControlDown())

3663

{

3664

postEvent(new java.awt.@event.ActionEvent(target, java.awt.@event.ActionEvent.ACTION_PERFORMED,

3665

getText(), e.getWhen(), e.getModifiers()));

3666

return true;

3667

}

3668

break;

3669

}

3670

return false;

3671

}

3672

}

3673

3674

sealed class NetTextAreaPeer : NetTextComponentPeer<java.awt.TextArea>, java.awt.peer.TextAreaPeer

3675

{

3676

public NetTextAreaPeer(java.awt.TextArea textArea)

3677

: base(textArea)

3678

{

3679

control.ReadOnly = !((java.awt.TextArea)target).isEditable();

3680

control.WordWrap = false;

3681

control.ScrollBars = ScrollBars.Both;

3682

control.Multiline = true;

3683

}

3684

3685

public void insert(string text, int pos)

3686

{

3687

NetToolkit.Invoke(delegate { control.Text = control.Text.Insert(pos, text); });

3688

}

3689

3690

public void insertText(string text, int pos)

3691

{

3692

insert(text, pos);

3693

}

3694

3695

public override java.awt.Dimension getMinimumSize()

3696

{

3697

return getMinimumSize(10, 60);

3698

}

3699

3700

public java.awt.Dimension minimumSize(int rows, int cols)

3701

{

3702

return getMinimumSize(rows, cols);

3703

}

3704

3705

public java.awt.Dimension getMinimumSize(int rows, int cols)

3706

{

3707

java.awt.FontMetrics fm = getFontMetrics(target.getFont());

3708

return new java.awt.Dimension(fm.charWidth('0') * cols + 20, fm.getHeight() * rows + 20);

3709

}

3710

3711

public java.awt.Dimension preferredSize(int rows, int cols)

3712

{

3713

return getPreferredSize(rows, cols);

3714

}

3715

3716

public java.awt.Dimension getPreferredSize(int rows, int cols)

3717

{

3718

return getMinimumSize(rows, cols);

3719

}

3720

3721

public void replaceRange(string text, int start_pos, int end_pos)

3722

{

3723

throw new NotImplementedException();

3724

}

3725

public void replaceText(string text, int start_pos, int end_pos)

3726

{

3727

throw new NotImplementedException();

3728

}

3729

}

3730

3731

class NetContainerPeer<T, C> : NetComponentPeer<T, C>, java.awt.peer.ContainerPeer

3732

where T : java.awt.Container

3733

where C : Control

3734

{

3735

/// <summary>

3736

/// The native insets of the .NET Window

3737

/// </summary>

3738

protected java.awt.Insets _insets = new java.awt.Insets(0, 0, 0, 0);

3739

3740

public NetContainerPeer(java.awt.Container awtcontainer)

3741

: base((T)awtcontainer)

3742

{

3743

}

3744

3745

internal override int getInsetsLeft()

3746

{

3747

return _insets.left; ;

3748

}

3749

3750

internal override int getInsetsTop()

3751

{

3752

return _insets.top;

3753

}

3754

3755

public java.awt.Insets insets()

3756

{

3757

return getInsets();

3758

}

3759

3760

public java.awt.Insets getInsets()

3761

{

3762

return _insets;

3763

}

3764

3765

public bool isRestackSupported()

3766

{

3767

return false;

3768

}

3769

3770

public void cancelPendingPaint(int x, int y, int width, int height)

3771

{

3772

throw new NotImplementedException();

3773

}

3774

3775

public void restack()

3776

{

3777

throw new NotImplementedException();

3778

}

3779

3780

protected override C CreateControl()

3781

{

3782

throw new NotImplementedException();

3783

}

3784

}

3785

3786

sealed class NetPanelPeer : NetContainerPeer<java.awt.Panel, ContainerControl>, java.awt.peer.PanelPeer

3787

{

3788

public NetPanelPeer(java.awt.Panel panel)

3789

: base(panel)

3790

{

3791

}

3792

3793

protected override ContainerControl CreateControl()

3794

{

3795

return new ContainerControl();

3796

}

3797

}

3798

3799

sealed class NetCanvasPeer : NetComponentPeer<java.awt.Canvas, Control>, java.awt.peer.CanvasPeer

3800

{

3801

public NetCanvasPeer(java.awt.Canvas canvas)

3802

: base(canvas)

3803

{

3804

}

3805

3806

protected override Control CreateControl()

3807

{

3808

return new Control();

3809

}

3810

3811

/**

3812

* Requests a GC that best suits this Canvas. The returned GC may differ

3813

* from the requested GC passed as the argument to this method. This method

3814

* must return a non-null value (given the argument is non-null as well).

3815

3816

* @since 1.7

3817

3818

public java.awt.GraphicsConfiguration getAppropriateGraphicsConfiguration(java.awt.GraphicsConfiguration gc)

3819

{

3820

return gc;

3821

}

3822

}

3823

3824

class NetWindowPeer : NetContainerPeer<java.awt.Window, Form>, java.awt.peer.WindowPeer

3825

{

3826

// we can't use NetDialogPeer as blocker may be an instance of NetPrintDialogPeer that

3827

// extends NetWindowPeer, not NetDialogPeer

3828

private NetWindowPeer modalBlocker;

3829

private bool modalSavedEnabled;

3830

3831

private static NetWindowPeer grabbedWindow;

3832

3833

public NetWindowPeer(java.awt.Window window, bool isFocusableWindow, bool isAlwaysOnTop)

3834

: base(window)

3835

{

3836

//form.Shown += new EventHandler(OnOpened); Will already post in java.awt.Window.show()

3837

control.Closing += new CancelEventHandler(OnClosing);

3838

control.Closed += new EventHandler(OnClosed);

3839

control.Activated += new EventHandler(OnActivated);

3840

control.Deactivate += new EventHandler(OnDeactivate);

3841

control.SizeChanged += new EventHandler(OnSizeChanged);

3842

control.Resize += new EventHandler(OnResize);

3843

control.Move += new EventHandler(OnMove);

3844

((UndecoratedForm)control).SetWindowState(isFocusableWindow, isAlwaysOnTop);

3845

}

3846

3847

protected override void initialize()

3848

{

3849

base.initialize();

3850

updateIconImages();

3851

if (target.getBackground() == null)

3852

{

3853

AWTAccessor.getComponentAccessor().setBackground(target, target is java.awt.Dialog ? java.awt.SystemColor.control : java.awt.SystemColor.window);

3854

}

3855

control.BackColor = J2C.ConvertColor(target.getBackground());

3856

if (target.getForeground() == null)

3857

{

3858

target.setForeground(java.awt.SystemColor.windowText);

3859

}

3860

if (target.getFont() == null)

3861

{

3862

//target.setFont(defaultFont);

3863

//HACK: Sun is calling setFont(Font) here and this is calling firePropertyChange("font", oldFont, newFont)

3864

//but this produce a deadlock with getTreeLock() because the creating of the peer is already in this synchronized

3865

java.security.AccessController.doPrivileged(Delegates.toPrivilegedAction(delegate

3866

{

3867

java.lang.Class component = typeof(java.awt.Component);

3868

java.lang.reflect.Field field = component.getDeclaredField("font");

3869

field.setAccessible(true);

3870

field.set(target, defaultFont);

3871

java.lang.reflect.Method method = component.getDeclaredMethod(

3872

"firePropertyChange",

3873

typeof(java.lang.String),

3874

typeof(java.lang.Object),

3875

typeof(java.lang.Object));

3876

method.setAccessible(true);

3877

method.invoke(target, "font", null, defaultFont);

3878

return null;

3879

}));

3880

}

3881

}

3882

3883

private void OnResize(object sender, EventArgs e)

3884

{

3885

// WmSizing

3886

SendComponentEvent(java.awt.@event.ComponentEvent.COMPONENT_RESIZED);

3887

dynamicallyLayoutContainer();

3888

}

3889

3890

private void OnMove(object sender, EventArgs e)

3891

{

3892

// WmMove

3893

AWTAccessor.getComponentAccessor().setLocation(target, control.Left, control.Top);

3894

SendComponentEvent(java.awt.@event.ComponentEvent.COMPONENT_MOVED);

3895

}

3896

3897

3898

* Although this function sends ComponentEvents, it needs to be defined

3899

* here because only top-level windows need to have move and resize

3900

* events fired from native code. All contained windows have these events

3901

* fired from common Java code.

3902

3903

private void SendComponentEvent(int eventId)

3904

{

3905

SendEvent(new java.awt.@event.ComponentEvent(target, eventId));

3906

}

3907

3908

private void OnSizeChanged(object sender, EventArgs e)

3909

{

3910

// WmSize

3911

typeof(java.awt.Component).GetField("width", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(target, control.Width);

3912

typeof(java.awt.Component).GetField("height", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(target, control.Height);

3913

SendComponentEvent(java.awt.@event.ComponentEvent.COMPONENT_RESIZED);

3914

}

3915

3916

private void OnOpened(object sender, EventArgs e)

3917

{

3918

postEvent(new java.awt.@event.WindowEvent((java.awt.Window)target, java.awt.@event.WindowEvent.WINDOW_OPENED));

3919

}

3920

3921

private void OnClosing(object sender, CancelEventArgs e)

3922

{

3923

e.Cancel = true;

3924

postEvent(new java.awt.@event.WindowEvent((java.awt.Window)target, java.awt.@event.WindowEvent.WINDOW_CLOSING));

3925

}

3926

3927

private void OnClosed(object sender, EventArgs e)

3928

{

3929

postEvent(new java.awt.@event.WindowEvent((java.awt.Window)target, java.awt.@event.WindowEvent.WINDOW_CLOSED));

3930

}

3931

3932

private const int WA_ACTIVE = 1;

3933

private const int WA_INACTIVE = 2;

3934

3935

private void OnActivated(object sender, EventArgs e)

3936

{

3937

WmActivate(WA_ACTIVE, control.WindowState == FormWindowState.Minimized, null);

3938

}

3939

3940

private void OnDeactivate(object sender, EventArgs e)

3941

{

3942

WmActivate(WA_INACTIVE, control.WindowState == FormWindowState.Minimized, null);

3943

}

3944

3945

private void WmActivate(int nState, bool fMinimized, Control opposite)

3946

{

3947

int type;

3948

3949

if (nState != WA_INACTIVE)

3950

{

3951

type = java.awt.@event.WindowEvent.WINDOW_GAINED_FOCUS;

3952

}

3953

else

3954

{

3955

if (grabbedWindow != null && !grabbedWindow.IsOneOfOwnersOf(this))

3956

{

3957

grabbedWindow.Ungrab(true);

3958

}

3959

type = java.awt.@event.WindowEvent.WINDOW_LOST_FOCUS;

3960

}

3961

3962

SendWindowEvent(type, opposite);

3963

}

3964

3965

private void SendWindowEvent(int id, Control opposite) { SendWindowEvent(id, opposite, 0, 0); }

3966

3967

private void SendWindowEvent(int id, Control opposite, int oldState, int newState)

3968

{

3969

java.awt.AWTEvent evt = new java.awt.@event.WindowEvent((java.awt.Window)target, id, null);

3970

3971

if (id == java.awt.@event.WindowEvent.WINDOW_GAINED_FOCUS

3972

|| id == java.awt.@event.WindowEvent.WINDOW_LOST_FOCUS)

3973

{

3974

Type type = typeof(java.awt.Component).Assembly.GetType("java.awt.SequencedEvent");

3975

ConstructorInfo cons = type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, new Type[] { typeof(java.awt.AWTEvent) }, null);

3976

evt = (java.awt.AWTEvent)cons.Invoke(new object[] { evt });

3977

}

3978

3979

SendEvent(evt);

3980

}

3981

3982

public override java.awt.Graphics getGraphics()

3983

{

3984

java.awt.Graphics g = base.getGraphics();

3985

java.awt.Insets insets = getInsets();

3986

g.translate(-insets.left, -insets.top);

3987

g.setClip(insets.left, insets.top, control.ClientRectangle.Width, control.ClientRectangle.Height);

3988

return g;

3989

}

3990

3991

public override bool shouldClearRectBeforePaint()

3992

{

3993

// clearing the window before repainting causes the controls to "flicker" on screen

3994

return false;

3995

}

3996

3997

/// <summary>

3998

/// Set the border style of the window and recalc the insets

3999

/// </summary>

4000

/// <param name="style">the new style</param>

4001

protected void setFormBorderStyle(FormBorderStyle style)

4002

{

4003

NetToolkit.BeginInvoke(delegate

4004

{

4005

control.FormBorderStyle = style;

4006

//Calculate the Insets one time

4007

//This is many faster because there no thread change is needed.

4008

CalcInsetsImpl();

4009

});

4010

}

4011

4012

protected void CalcInsetsImpl()

4013

{

4014

Rectangle client = control.ClientRectangle;

4015

if (client.Height == 0)

4016

{

4017

// HACK for .NET bug if form has the minimum size then ClientRectangle is not recalulate

4018

// if the FormBorderStyle is changed

4019

Size size = control.Size;

4020

size.Height++;

4021

control.Size = size;

4022

size.Height--;

4023

control.Size = size;

4024

client = control.ClientRectangle;

4025

}

4026

Rectangle r = control.RectangleToScreen(client);

4027

int x = r.Location.X - control.Location.X;

4028

int y = r.Location.Y - control.Location.Y;

4029

// only modify this instance, since it's shared by the control-peers of this form

4030

_insets.top = y;

4031

_insets.left = x;

4032

_insets.bottom = control.Height - client.Height - y;

4033

if (control.Menu != null)

4034

{

4035

_insets.bottom += SystemInformation.MenuHeight;

4036

}

4037

_insets.right = control.Width - client.Width - x;

4038

}

4039

4040

public override void reshape(int x, int y, int width, int height)

4041

{

4042

NetToolkit.BeginInvoke(delegate

4043

{

4044

control.SetBounds(x, y, width, height);

4045

//If the .NET control does not accept the new bounds (minimum size, maximum size)

4046

//then we need to reflect the real bounds on the .NET site to the Java site

4047

Rectangle bounds = control.Bounds;

4048

if (bounds.X != x || bounds.Y != y)

4049

{

4050

AWTAccessor.getComponentAccessor().setLocation(target, bounds.X, bounds.Y);

4051

}

4052

if (bounds.Width != width || bounds.Height != height)

4053

{

4054

AWTAccessor.getComponentAccessor().setSize(target, bounds.Width, bounds.Height);

4055

}

4056

});

4057

}

4058

4059

public void toBack()

4060

{

4061

NetToolkit.BeginInvoke(control.SendToBack);

4062

}

4063

4064

public void toFront()

4065

{

4066

NetToolkit.BeginInvoke(control.Activate);

4067

}

4068

4069

public bool requestWindowFocus()

4070

{

4071

return NetToolkit.Invoke<bool>(control.Focus);

4072

}

4073

4074

public void setAlwaysOnTop(bool alwaysOnTop)

4075

{

4076

// The .NET property TopMost does not work with a not focusable Window

4077

// that we need to set the window flags directly. To reduce double code

4078

// we call updateFocusableWindowState().

4079

updateFocusableWindowState();

4080

}

4081

4082

public bool isModalBlocked()

4083

{

4084

return modalBlocker != null;

4085

}

4086

4087

public void setModalBlocked(java.awt.Dialog dialog, bool blocked)

4088

{

4089

lock (target.getTreeLock()) // State lock should always be after awtLock

4090

{

4091

// use NetWindowPeer instead of NetDialogPeer because of FileDialogs and PrintDialogs

4092

NetWindowPeer blockerPeer = (NetWindowPeer)dialog.getPeer();

4093

if (blocked)

4094

{

4095

modalBlocker = blockerPeer;

4096

modalSavedEnabled = control.Enabled;

4097

disable();

4098

}

4099

else

4100

{

4101

modalBlocker = null;

4102

if(modalSavedEnabled){

4103

enable();

4104

}

4105

else

4106

{

4107

disable();

4108

}

4109

}

4110

}

4111

}

4112

4113

public void updateFocusableWindowState()

4114

{

4115

((UndecoratedForm)control).SetWindowState(((java.awt.Window)target).isFocusableWindow(), ((java.awt.Window)target).isAlwaysOnTop());

4116

}

4117

4118

public void updateIconImages()

4119

{

4120

java.util.List imageList = ((java.awt.Window)target).getIconImages();

4121

Icon icon;

4122

if (imageList == null || imageList.size() == 0)

4123

{

4124

icon = null;

4125

}

4126

else

4127

{

4128

IconFactory factory = new IconFactory();

4129

icon = factory.CreateIcon(imageList, SystemInformation.IconSize);

4130

}

4131

NetToolkit.BeginInvoke(delegate

4132

{

4133

((Form)control).Icon = icon;

4134

});

4135

}

4136

4137

public void updateMinimumSize()

4138

{

4139

java.awt.Dimension dim = target.getMinimumSize();

4140

NetToolkit.BeginInvoke(delegate

4141

{

4142

control.MinimumSize = new Size(dim.width, dim.height);

4143

});

4144

}

4145

4146

/**

4147

* Sets the level of opacity for the window.

4148

4149

* @see Window#setOpacity(float)

4150

4151

public void setOpacity(float opacity)

4152

{

4153

throw new ikvm.@internal.NotYetImplementedError();

4154

}

4155

4156

/**

4157

* Enables the per-pixel alpha support for the window.

4158

4159

* @see Window#setBackground(Color)

4160

4161

public void setOpaque(bool isOpaque)

4162

{

4163

throw new ikvm.@internal.NotYetImplementedError();

4164

}

4165

4166

4167

/**

4168

* Updates the native part of non-opaque window.

4169

4170

* @see Window#setBackground(Color)

4171

4172

public void updateWindow()

4173

{

4174

throw new ikvm.@internal.NotYetImplementedError();

4175

}

4176

4177

4178

/**

4179

* Instructs the peer to update the position of the security warning.

4180

4181

public void repositionSecurityWarning()

4182

{

4183

throw new ikvm.@internal.NotYetImplementedError();

4184

}

4185

4186

4187

4188

protected override Form CreateControl()

4189

{

4190

return new UndecoratedForm();

4191

}

4192

4193

protected override void OnMouseDown(object sender, MouseEventArgs ev)

4194

{

4195

if (grabbedWindow != null && !grabbedWindow.IsOneOfOwnersOf(this))

4196

{

4197

grabbedWindow.Ungrab(true);

4198

}

4199

base.OnMouseDown(sender, ev);

4200

}

4201

4202

internal void Grab()

4203

{

4204

//copy from file awt_Windows.cpp

4205

if (grabbedWindow != null)

4206

{

4207

grabbedWindow.Ungrab(true);

4208

}

4209

grabbedWindow = this;

4210

if (Form.ActiveForm == null)

4211

{

4212

Ungrab(true);

4213

}

4214

else if (control != Form.ActiveForm)

4215

{

4216

toFront();

4217

}

4218

}

4219

4220

internal void Ungrab(bool doPost)

4221

{

4222

//copy from file awt_Windows.cpp

4223

if (grabbedWindow == this)

4224

{

4225

if (doPost)

4226

{

4227

SendEvent(new sun.awt.UngrabEvent(this.target));

4228

}

4229

grabbedWindow = null;

4230

}

4231

}

4232

4233

private bool IsOneOfOwnersOf(NetWindowPeer window)

4234

{

4235

while (window != null)

4236

{

4237

if (window == this)

4238

{

4239

return true;

4240

}

4241

java.awt.Container parent = window.target.getParent();

4242

window = parent == null ? null : (NetWindowPeer)parent.getPeer();

4243

}

4244

return false;

4245

}

4246

}

4247

4248

sealed class NetFramePeer : NetWindowPeer, java.awt.peer.FramePeer

4249

{

4250

public NetFramePeer(java.awt.Frame frame, bool isFocusableWindow, bool isAlwaysOnTop)

4251

: base(frame, isFocusableWindow, isAlwaysOnTop)

4252

{

4253

}

4254

4255

protected override void initialize()

4256

{

4257

base.initialize();

4258

java.awt.Frame target = (java.awt.Frame)this.target;

4259

4260

if (target.getTitle() != null)

4261

{

4262

setTitle(target.getTitle());

4263

}

4264

setResizable(target.isResizable());

4265

setState(target.getExtendedState());

4266

}

4267

4268

public void setMenuBar(java.awt.MenuBar mb)

4269

{

4270

if (mb == null)

4271

{

4272

NetToolkit.Invoke(delegate

4273

{

4274

control.Menu = null;

4275

CalcInsetsImpl();

4276

});

4277

}

4278

else

4279

{

4280

mb.addNotify();

4281

NetToolkit.Invoke(delegate

4282

{

4283

control.Menu = ((NetMenuBarPeer)mb.getPeer()).menu;

4284

CalcInsetsImpl();

4285

});

4286

}

4287

}

4288

4289

public void setResizable(bool resizable)

4290

{

4291

if (((java.awt.Frame)target).isUndecorated())

4292

{

4293

setFormBorderStyle(FormBorderStyle.None);

4294

}

4295

else

4296

{

4297

if (resizable)

4298

{

4299

setFormBorderStyle(FormBorderStyle.Sizable);

4300

}

4301

else

4302

{

4303

setFormBorderStyle(FormBorderStyle.FixedSingle);

4304

}

4305

}

4306

}

4307

4308

public void setTitle(string title)

4309

{

4310

NetToolkit.BeginInvoke(delegate { control.Text = title; });

4311

}

4312

4313

public int getState()

4314

{

4315

Form f = (Form)control;

4316

FormWindowState state = f.WindowState;

4317

switch (state)

4318

{

4319

case FormWindowState.Normal:

4320

return java.awt.Frame.NORMAL;

4321

case FormWindowState.Maximized:

4322

return java.awt.Frame.MAXIMIZED_BOTH;

4323

case FormWindowState.Minimized:

4324

return java.awt.Frame.ICONIFIED;

4325

default:

4326

throw new InvalidEnumArgumentException();

4327

}

4328

}

4329

4330

public void setState(int state)

4331

{

4332

NetToolkit.BeginInvoke(delegate

4333

{

4334

MyForm form = (MyForm) control;

4335

switch(state)

4336

{

4337

case java.awt.Frame.NORMAL:

4338

form.WindowState = FormWindowState.Normal;

4339

break;

4340

case java.awt.Frame.MAXIMIZED_BOTH:

4341

form.WindowState = FormWindowState.Maximized;

4342

break;

4343

case java.awt.Frame.ICONIFIED:

4344

form.WindowState = FormWindowState.Minimized;

4345

break;

4346

}

4347

});

4348

}

4349

4350

public void setMaximizedBounds(java.awt.Rectangle rect)

4351

{

4352

((MyForm)control).setMaximizedBounds(rect);

4353

}

4354

4355

public void setBoundsPrivate(int x, int y, int width, int height)

4356

{

4357

NetToolkit.Invoke(delegate { control.Bounds = new Rectangle(x, y, width, height); });

4358

}

4359

4360

public java.awt.Rectangle getBoundsPrivate()

4361

{

4362

throw new NotImplementedException();

4363

}

4364

4365

protected override Form CreateControl()

4366

{

4367

return new MyForm(_insets);

4368

}

4369

}

4370

4371

sealed class NetDialogPeer : NetWindowPeer, java.awt.peer.DialogPeer

4372

{

4373

public NetDialogPeer(java.awt.Dialog target, bool isFocusableWindow, bool isAlwaysOnTop)

4374

: base(target, isFocusableWindow, isAlwaysOnTop)

4375

{

4376

control.MaximizeBox = false;

4377

control.MinimizeBox = false;

4378

control.ShowInTaskbar = false;

4379

setTitle(target.getTitle());

4380

setResizable(target.isResizable());

4381

}

4382

4383

public void setTitle(string title)

4384

{

4385

NetToolkit.Invoke(delegate { control.Text = title; });

4386

}

4387

4388

public void setResizable(bool resizable)

4389

{

4390

if (((java.awt.Dialog)target).isUndecorated())

4391

{

4392

setFormBorderStyle(FormBorderStyle.None);

4393

}

4394

else

4395

{

4396

if (resizable)

4397

{

4398

setFormBorderStyle(FormBorderStyle.Sizable);

4399

}

4400

else

4401

{

4402

setFormBorderStyle(FormBorderStyle.FixedSingle);

4403

}

4404

}

4405

}

4406

4407

public void blockWindows(List toBlock)

4408

{

4409

// code copies from sun.awt.windows.WDialogPeer.java

4410

for (Iterator it = toBlock.iterator(); it.hasNext();) {

4411

java.awt.Window w = (java.awt.Window)it.next();

4412

java.awt.peer.WindowPeer wp = (java.awt.peer.WindowPeer)AWTAccessor.getComponentAccessor().getPeer(w);

4413

if (wp != null) {

4414

wp.setModalBlocked((java.awt.Dialog)target, true);

4415

}

4416

}

4417

}

4418

4419

protected override Form CreateControl()

4420

{

4421

return new MyForm(_insets);

4422

}

4423

}

4424

4425

sealed class NetKeyboardFocusManagerPeer : java.awt.peer.KeyboardFocusManagerPeer

4426

{

4427

//private readonly java.awt.KeyboardFocusManager manager;

4428

private static java.lang.reflect.Method m_removeLastFocusRequest;

4429

4430

public NetKeyboardFocusManagerPeer(java.awt.KeyboardFocusManager manager)

4431

{

4432

//this.manager = manager;

4433

}

4434

4435

public void clearGlobalFocusOwner(java.awt.Window activeWindow)

4436

{

4437

}

4438

4439

public java.awt.Component getCurrentFocusOwner()

4440

{

4441

return getNativeFocusOwner();

4442

}

4443

4444

public void setCurrentFocusOwner(java.awt.Component component)

4445

{

4446

}

4447

4448

public java.awt.Window getCurrentFocusedWindow()

4449

{

4450

return getNativeFocusedWindow();

4451

}

4452

4453

private static java.awt.Component getNativeFocusOwner()

4454

{

4455

return NetToolkit.Invoke<java.awt.Component>(delegate

4456

{

4457

UndecoratedForm form = Form.ActiveForm as UndecoratedForm;

4458

if (form != null)

4459

{

4460

Control control = form.ActiveControl;

4461

while (control is ContainerControl)

4462

{

4463

control = ((ContainerControl)control).ActiveControl;

4464

}

4465

NetComponentPeer peer;

4466

if (control == null)

4467

{

4468

peer = NetComponentPeer.FromControl(form);

4469

}

4470

else

4471

{

4472

while ((peer = NetComponentPeer.FromControl(form)) == null)

4473

{

4474

control = control.Parent;

4475

}

4476

}

4477

return peer.Target;

4478

}

4479

return null;

4480

});

4481

}

4482

4483

private static java.awt.Window getNativeFocusedWindow()

4484

{

4485

return NetToolkit.Invoke<java.awt.Window>(delegate

4486

{

4487

Form form = Form.ActiveForm;

4488

if (form != null)

4489

{

4490

NetComponentPeer peer = NetComponentPeer.FromControl(form);

4491

if (peer != null)

4492

{

4493

return (java.awt.Window)peer.Target;

4494

}

4495

}

4496

return null;

4497

});

4498

}

4499

4500

public static void removeLastFocusRequest(java.awt.Component heavyweight)

4501

{

4502

try

4503

{

4504

if (m_removeLastFocusRequest == null)

4505

{

4506

m_removeLastFocusRequest = SunToolkit.getMethod(typeof(java.awt.KeyboardFocusManager), "removeLastFocusRequest",

4507

new java.lang.Class[] { typeof(java.awt.Component) });

4508

}

4509

m_removeLastFocusRequest.invoke(null, new Object[] { heavyweight });

4510

}

4511

catch (java.lang.reflect.InvocationTargetException ite)

4512

{

4513

ite.printStackTrace();

4514

}

4515

catch (java.lang.IllegalAccessException ex)

4516

{

4517

ex.printStackTrace();

4518

}

4519

}

4520

}

4521

4522

sealed class NetListPeer : NetComponentPeer<java.awt.List, ListBox>, java.awt.peer.ListPeer

4523

{

4524

internal NetListPeer(java.awt.List target)

4525

: base(target)

4526

{

4527

control.IntegralHeight = false;

4528

setMultipleMode(target.isMultipleMode());

4529

for (int i = 0; i < target.getItemCount(); i++)

4530

{

4531

add(target.getItem(i), i);

4532

if (target.isSelected(i))

4533

{

4534

select(i);

4535

}

4536

}

4537

makeVisible(target.getVisibleIndex());

4538

}

4539

4540

public void add(string item, int index)

4541

{

4542

NetToolkit.Invoke(delegate { control.Items.Insert(index, item); });

4543

}

4544

4545

public void addItem(string item, int index)

4546

{

4547

add(item, index);

4548

}

4549

4550

public void clear()

4551

{

4552

NetToolkit.Invoke(delegate { control.Items.Clear(); });

4553

}

4554

4555

public void delItems(int start_index, int end_index)

4556

{

4557

NetToolkit.Invoke(delegate

4558

{

4559

for (int i = start_index; i < end_index; i++)

4560

{

4561

control.Items.RemoveAt(start_index);

4562

}

4563

});

4564

}

4565

4566

public void deselect(int index)

4567

{

4568

NetToolkit.Invoke(delegate { control.SelectedIndices.Remove(index); });

4569

}

4570

4571

public int[] getSelectedIndexes()

4572

{

4573

return NetToolkit.Invoke<int[]>(delegate

4574

{

4575

ListBox.SelectedIndexCollection sic = control.SelectedIndices;

4576

int[] indexes = new int[sic.Count];

4577

sic.CopyTo(indexes, 0);

4578

return indexes;

4579

});

4580

}

4581

4582

public void makeVisible(int index)

4583

{

4584

NetToolkit.Invoke(delegate { control.TopIndex = index; });

4585

}

4586

4587

public java.awt.Dimension minimumSize(int s)

4588

{

4589

return getMinimumSize(s);

4590

}

4591

4592

public java.awt.Dimension preferredSize(int s)

4593

{

4594

return getPreferredSize(s);

4595

}

4596

4597

public void removeAll()

4598

{

4599

clear();

4600

}

4601

4602

public void select(int index)

4603

{

4604

NetToolkit.Invoke(delegate { control.SelectedIndices.Add(index); });

4605

}

4606

4607

public void setMultipleMode(bool multi)

4608

{

4609

NetToolkit.Invoke(delegate { control.SelectionMode = multi ? SelectionMode.MultiSimple : SelectionMode.One; });

4610

}

4611

4612

public void setMultipleSelections(bool multi)

4613

{

4614

setMultipleMode(multi);

4615

}

4616

4617

public java.awt.Dimension getPreferredSize(int s)

4618

{

4619

return getMinimumSize(s);

4620

}

4621

4622

public java.awt.Dimension getMinimumSize(int s)

4623

{

4624

return new java.awt.Dimension(100, 100);

4625

}

4626

4627

protected override ListBox CreateControl()

4628

{

4629

return new ListBox();

4630

}

4631

}

4632

4633

sealed class NetDesktopPeer : java.awt.peer.DesktopPeer

4634

{

4635

private static void ShellExecute(string file, string verb)

4636

{

4637

try

4638

{

4639

ProcessStartInfo psi = new ProcessStartInfo(file);

4640

psi.UseShellExecute = true;

4641

psi.Verb = verb;

4642

Process p = Process.Start(psi);

4643

if (p != null)

4644

{

4645

p.Dispose();

4646

}

4647

}

4648

catch (System.ComponentModel.Win32Exception x)

4649

{

4650

throw new java.io.IOException(x.Message);

4651

}

4652

}

4653

4654

public void browse(URI uri)

4655

{

4656

ShellExecute(uri.toString(), "open");

4657

}

4658

4659

public void edit(java.io.File f)

4660

{

4661

ShellExecute(f.toString(), "edit");

4662

}

4663

4664

public bool isSupported(java.awt.Desktop.Action da)

4665

{

4666

return da == java.awt.Desktop.Action.BROWSE

4667

|| da == java.awt.Desktop.Action.EDIT

4668

|| da == java.awt.Desktop.Action.MAIL

4669

|| da == java.awt.Desktop.Action.OPEN

4670

|| da == java.awt.Desktop.Action.PRINT;

4671

}

4672

4673

public void mail(URI uri)

4674

{

4675

if (uri.getScheme().ToLower(System.Globalization.CultureInfo.InvariantCulture) != "mailto")

4676

{

4677

throw new java.lang.IllegalArgumentException("URI scheme is not \"mailto\"");

4678

}

4679

ShellExecute(uri.toString(), "open");

4680

}

4681

4682

public void mail()

4683

{

4684

ShellExecute("mailto:", "open");

4685

}

4686

4687

public void open(java.io.File f)

4688

{

4689

ShellExecute(f.toString(), "open");

4690

}

4691

4692

public void print(java.io.File f)

4693

{

4694

ShellExecute(f.toString(), "print");

4695

}

4696

}

4697

4698

//also WFileDialogPeer extends from WWindowPeer

4699

class NetFileDialogPeer : NetWindowPeer, java.awt.peer.FileDialogPeer

4700

{

4701

internal NetFileDialogPeer(java.awt.FileDialog dialog, bool isFocusableWindow, bool isAlwaysOnTop)

4702

: base(dialog, isFocusableWindow, isAlwaysOnTop)

4703

{

4704

}

4705

4706

public void setDirectory(string str)

4707

{

4708

}

4709

4710

public void setFile(string str)

4711

{

4712

}

4713

4714

public void setFilenameFilter(java.io.FilenameFilter ff)

4715

{

4716

}

4717

4718

public void setResizable(bool b)

4719

{

4720

}

4721

4722

public void setTitle(string str)

4723

{

4724

}

4725

4726

public override void show()

4727

{

4728

java.awt.FileDialog dialog = (java.awt.FileDialog)target;

4729

if (dialog.getMode() != java.awt.FileDialog.LOAD)

4730

{

4731

throw new NotImplementedException();

4732

}

4733

Thread t = new Thread((ThreadStart)delegate

4734

{

4735

using (OpenFileDialog dlg = new OpenFileDialog())

4736

{

4737

if (dlg.ShowDialog() == DialogResult.OK)

4738

{

4739

dialog.setFile(Path.GetFileName(dlg.FileName));

4740

dialog.setDirectory(Path.GetDirectoryName(dlg.FileName) + java.io.File.separator);

4741

dialog.hide();

4742

}

4743

else

4744

{

4745

dialog.setFile(null);

4746

dialog.hide();

4747

}

4748

}

4749

});

4750

t.SetApartmentState(ApartmentState.STA);

4751

t.Start();

4752

}

4753

4754

public void blockWindows(List toBlock)

4755

{

4756

// code copies from sun.awt.windows.WFileDialogPeer.java

4757

for (Iterator it = toBlock.iterator(); it.hasNext(); ) {

4758

java.awt.Window w = (java.awt.Window)it.next();

4759

java.awt.peer.WindowPeer wp = (java.awt.peer.WindowPeer)AWTAccessor.getComponentAccessor().getPeer(w);

4760

if (wp != null) {

4761

wp.setModalBlocked((java.awt.Dialog)target, true);

4762

}

4763

}

4764

}

4765

}

4766

4767

class NetSystemTrayPeer : java.awt.peer.SystemTrayPeer

4768

{

4769

//private java.awt.SystemTray target;

4770

4771

internal NetSystemTrayPeer(java.awt.SystemTray target)

4772

{

4773

//this.target = target;

4774

}

4775

4776

public java.awt.Dimension getTrayIconSize()

4777

{

4778

return new java.awt.Dimension(NetTrayIconPeer.TRAY_ICON_WIDTH, NetTrayIconPeer.TRAY_ICON_HEIGHT);

4779

}

4780

4781

public bool isSupported()

4782

{

4783

return ((NetToolkit) java.awt.Toolkit.getDefaultToolkit()).isTraySupported();

4784

}

4785

}

4786

4787

sealed class NetPopupMenuPeer : java.awt.peer.PopupMenuPeer

4788

{

4789

private readonly java.awt.PopupMenu target;

4790

private readonly ContextMenu menu = new ContextMenu();

4791

4792

internal NetPopupMenuPeer(java.awt.PopupMenu target)

4793

{

4794

this.target = target;

4795

for (int i = 0; i < target.getItemCount(); i++)

4796

{

4797

addItem(target.getItem(i));

4798

}

4799

}

4800

4801

public void show(java.awt.Event e)

4802

{

4803

show((java.awt.Component)e.target, new java.awt.Point(e.x, e.y));

4804

}

4805

4806

public void show(java.awt.Component origin, java.awt.Point p)

4807

{

4808

NetComponentPeer peer = (NetComponentPeer)origin.getPeer();

4809

Point pt = new Point(p.x, p.y);

4810

pt.Offset(- peer.getInsetsLeft(), - peer.getInsetsTop());

4811

NetToolkit.Invoke(delegate { menu.Show(peer.Control, pt); });

4812

}

4813

4814

public void dispose()

4815

{

4816

NetToolkit.Invoke(delegate { menu.Dispose(); });

4817

}

4818

4819

public void setFont(java.awt.Font f)

4820

{

4821

throw new NotImplementedException();

4822

}

4823

4824

public void disable()

4825

{

4826

setEnabled(false);

4827

}

4828

4829

public void enable()

4830

{

4831

setEnabled(true);

4832

}

4833

4834

public void setEnabled(bool b)

4835

{

4836

NetToolkit.Invoke(delegate

4837

{

4838

for (int i = 0; i < target.getItemCount(); i++)

4839

{

4840

menu.MenuItems[i].Enabled = b && target.getItem(i).isEnabled();

4841

}

4842

});

4843

}

4844

4845

public void setLabel(string str)

4846

{

4847

}

4848

4849

public void addItem(java.awt.MenuItem item)

4850

{

4851

if (item.getPeer() == null)

4852

{

4853

item.addNotify();

4854

}

4855

if (item.getPeer() is NetMenuItemPeer)

4856

{

4857

NetToolkit.Invoke(delegate { menu.MenuItems.Add(((NetMenuItemPeer)item.getPeer()).menuitem); });

4858

}

4859

else

4860

{

4861

NetToolkit.Invoke(delegate { menu.MenuItems.Add(((NetMenuPeer)item.getPeer()).menu); });

4862

}

4863

}

4864

4865

public void addSeparator()

4866

{

4867

NetToolkit.Invoke(delegate { menu.MenuItems.Add(new MenuItem("-")); });

4868

}

4869

4870

public void delItem(int i)

4871

{

4872

NetToolkit.Invoke(delegate { menu.MenuItems.RemoveAt(i); });

4873

}

4874

}

4875

4876

class NetTrayIconPeer : java.awt.peer.TrayIconPeer

4877

{

4878

internal const int TRAY_ICON_WIDTH = 16;

4879

internal const int TRAY_ICON_HEIGHT = 16;

4880

internal const int TRAY_ICON_MASK_SIZE = TRAY_ICON_WIDTH*TRAY_ICON_HEIGHT/8;

4881

4882

private java.awt.TrayIcon target;

4883

private NotifyIcon notifyIcon;

4884

private java.awt.Frame popupParent = new java.awt.Frame("PopupMessageWindow");

4885

private java.awt.PopupMenu popup;

4886

private bool disposed;

4887

private bool isPopupMenu;

4888

4889

internal NetTrayIconPeer(java.awt.TrayIcon target)

4890

{

4891

this.target = target;

4892

popupParent.addNotify();

4893

create();

4894

updateImage();

4895

}

4896

4897

public void displayMessage(string caption, string text, string messageType)

4898

{

4899

ToolTipIcon icon = ToolTipIcon.None;

4900

switch(messageType)

4901

{

4902

case "ERROR" :

4903

icon = ToolTipIcon.Error;

4904

break;

4905

case "WARNING" :

4906

icon = ToolTipIcon.Warning;

4907

break;

4908

case "INFO" :

4909

icon = ToolTipIcon.Info;

4910

break;

4911

case "NONE" :

4912

icon = ToolTipIcon.None;

4913

break;

4914

}

4915

NetToolkit.BeginInvoke(delegate

4916

{

4917

notifyIcon.ShowBalloonTip(10000, caption, text, icon);

4918

});

4919

}

4920

4921

private void create()

4922

{

4923

NetToolkit.Invoke(delegate

4924

{

4925

notifyIcon = new NotifyIcon();

4926

hookEvents();

4927

notifyIcon.Visible = true;

4928

});

4929

}

4930

4931

public void dispose()

4932

{

4933

bool callDisposed = true;

4934

lock (this)

4935

{

4936

if (disposed)

4937

callDisposed = false;

4938

disposed = true;

4939

}

4940

if (callDisposed)

4941

disposeImpl();

4942

}

4943

4944

protected void disposeImpl()

4945

{

4946

if (popupParent != null)

4947

{

4948

popupParent.dispose();

4949

}

4950

NetToolkit.targetDisposedPeer(target, this);

4951

NetToolkit.BeginInvoke(nativeDispose);

4952

}

4953

4954

private void hookEvents()

4955

{

4956

notifyIcon.MouseClick += new MouseEventHandler(OnClick);

4957

notifyIcon.MouseDoubleClick += new MouseEventHandler(OnDoubleClick);

4958

notifyIcon.MouseDown += new MouseEventHandler(OnMouseDown);

4959

notifyIcon.MouseUp += new MouseEventHandler(OnMouseUp);

4960

notifyIcon.MouseMove += new MouseEventHandler(OnMouseMove);

4961

}

4962

4963

private void unhookEvents()

4964

{

4965

notifyIcon.MouseClick -= new MouseEventHandler(OnClick);

4966

notifyIcon.MouseDoubleClick -= new MouseEventHandler(OnDoubleClick);

4967

notifyIcon.MouseDown -= new MouseEventHandler(OnMouseDown);

4968

notifyIcon.MouseUp -= new MouseEventHandler(OnMouseUp);

4969

notifyIcon.MouseMove -= new MouseEventHandler(OnMouseMove);

4970

}

4971

4972

internal void postEvent(java.awt.AWTEvent evt)

4973

{

4974

NetToolkit.postEvent(NetToolkit.targetToAppContext(target), evt);

4975

}

4976

4977

private void postMouseEvent(MouseEventArgs ev, int id, int clicks)

4978

{

4979

long when = java.lang.System.currentTimeMillis();

4980

int modifiers = NetComponentPeer.GetMouseEventModifiers(ev);

4981

int button = NetComponentPeer.GetButton(ev);

4982

int clickCount = clicks;

4983

int x = Control.MousePosition.X;

4984

int y = Control.MousePosition.Y;

4985

bool isPopup = isPopupMenu;

4986

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate

4987

{

4988

java.awt.Component fake = new java.awt.TextField();

4989

java.awt.@event.MouseEvent mouseEvent = new java.awt.@event.MouseEvent(fake, id, when, modifiers, x, y, clickCount, isPopup, button);

4990

mouseEvent.setSource(target);

4991

postEvent(mouseEvent);

4992

}));

4993

isPopupMenu = false;

4994

}

4995

4996

private void postMouseEvent(EventArgs ev, int id)

4997

{

4998

long when = java.lang.System.currentTimeMillis();

4999

int modifiers = NetComponentPeer.GetModifiers(Control.ModifierKeys);

5000

int button = 0;

5001

int clickCount = 0;

5002

int x = Control.MousePosition.X;

5003

int y = Control.MousePosition.Y;

5004

bool isPopup = isPopupMenu;

5005

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate

5006

{

5007

java.awt.Component fake = new java.awt.TextField();

5008

java.awt.@event.MouseEvent mouseEvent = new java.awt.@event.MouseEvent(fake, id, when, modifiers, x, y, clickCount, isPopup, button);

5009

mouseEvent.setSource(target);

5010

postEvent(mouseEvent);

5011

}));

5012

isPopupMenu = false;

5013

}

5014

5015

protected virtual void OnMouseDown(object sender, MouseEventArgs ev)

5016

{

5017

isPopupMenu = false;

5018

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_PRESSED, ev.Clicks);

5019

}

5020

5021

private void OnClick(object sender, MouseEventArgs ev)

5022

{

5023

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_CLICKED, ev.Clicks);

5024

}

5025

5026

private void OnDoubleClick(object sender, MouseEventArgs ev)

5027

{

5028

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_CLICKED, ev.Clicks);

5029

long when = java.lang.System.currentTimeMillis();

5030

int modifiers = NetComponentPeer.GetModifiers(Control.ModifierKeys);

5031

postEvent(new java.awt.@event.ActionEvent(target, java.awt.@event.ActionEvent.ACTION_PERFORMED, target.getActionCommand(), when, modifiers));

5032

}

5033

5034

private void OnMouseUp(object sender, MouseEventArgs ev)

5035

{

5036

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_RELEASED, ev.Clicks);

5037

}

5038

5039

private void OnMouseEnter(object sender, EventArgs ev)

5040

{

5041

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_ENTERED);

5042

}

5043

5044

private void OnMouseLeave(object sender, EventArgs ev)

5045

{

5046

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_EXITED);

5047

}

5048

5049

protected virtual void OnMouseMove(object sender, MouseEventArgs ev)

5050

{

5051

if ((ev.Button & (MouseButtons.Left | MouseButtons.Right)) != 0)

5052

{

5053

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_DRAGGED, ev.Clicks);

5054

}

5055

else

5056

{

5057

postMouseEvent(ev, java.awt.@event.MouseEvent.MOUSE_MOVED, ev.Clicks);

5058

}

5059

}

5060

5061

private void nativeDispose()

5062

{

5063

if (notifyIcon!=null)

5064

{

5065

unhookEvents();

5066

notifyIcon.Dispose();

5067

}

5068

}

5069

5070

public void setToolTip(string str)

5071

{

5072

NetToolkit.BeginInvoke(delegate { notifyIcon.Text = str; });

5073

}

5074

5075

protected bool isDisposed()

5076

{

5077

return disposed;

5078

}

5079

5080

public void showPopupMenu(int x, int y)

5081

{

5082

if (isDisposed())

5083

return;

5084

java.lang.Runnable runnable = Delegates.toRunnable(delegate

5085

{

5086

java.awt.PopupMenu newPopup = ((java.awt.TrayIcon)target).getPopupMenu();

5087

if (popup != newPopup) {

5088

if (popup != null) {

5089

popupParent.remove(popup);

5090

}

5091

if (newPopup != null) {

5092

popupParent.add(newPopup);

5093

}

5094

popup = newPopup;

5095

}

5096

if (popup != null) {

5097

((NetPopupMenuPeer)popup.getPeer()).show(popupParent, new java.awt.Point(x, y));

5098

}

5099

});

5100

SunToolkit.executeOnEventHandlerThread(target, runnable);

5101

}

5102

5103

public void updateImage()

5104

{

5105

java.awt.Image image = ((java.awt.TrayIcon) target).getImage();

5106

if (image != null)

5107

{

5108

updateNativeImage(image);

5109

}

5110

}

5111

5112

private void updateNativeImage(java.awt.Image image)

5113

{

5114

lock (this)

5115

{

5116

if (isDisposed())

5117

return;

5118

bool autosize = ((java.awt.TrayIcon) target).isImageAutoSize();

5119

5120

using (Bitmap bitmap = getNativeImage(image, autosize))

5121

{

5122

IntPtr hicon = bitmap.GetHicon();

5123

Icon icon = Icon.FromHandle(hicon);

5124

notifyIcon.Icon = icon;

5125

}

5126

}

5127

}

5128

5129

private Bitmap getNativeImage(java.awt.Image image, bool autosize)

5130

{

5131

if (image is NoImage)

5132

return new Bitmap(TRAY_ICON_WIDTH, TRAY_ICON_HEIGHT);

5133

else

5134

{

5135

Image netImage = J2C.ConvertImage(image);

5136

if (autosize)

5137

return new Bitmap(netImage, TRAY_ICON_WIDTH, TRAY_ICON_HEIGHT);

5138

else

5139

return new Bitmap(netImage);

5140

}

5141

}

5142

}

5143

5144

5145

internal class NetMouseInfoPeer : java.awt.peer.MouseInfoPeer

5146

{

5147

public int fillPointWithCoords(java.awt.Point p)

5148

{

5149

p.x = Cursor.Position.X;

5150

p.y = Cursor.Position.Y;

5151

//TODO multi screen device

5152

return 0; //return the number of the screen device

5153

}

5154

5155

[DllImport("user32.dll")]

5156

private static extern IntPtr WindowFromPoint(POINT Point);

5157

5158

[StructLayout(LayoutKind.Sequential)]

5159

private struct POINT

5160

{

5161

public int X;

5162

public int Y;

5163

5164

internal POINT(Point pt)

5165

{

5166

this.X = pt.X;

5167

this.Y = pt.Y;

5168

}

5169

}

5170

5171

public bool isWindowUnderMouse(java.awt.Window window)

5172

{

5173

if (NetToolkit.isWin32())

5174

{

5175

NetWindowPeer peer = (NetWindowPeer)window.getPeer();

5176

if (peer != null)

5177

{

5178

IntPtr hWnd = WindowFromPoint(new POINT(Cursor.Position));

5179

return peer.control.Handle.Equals(hWnd);

5180

}

5181

return false;

5182

}

5183

else

5184

{

5185

throw new NotImplementedException();

5186

}

5187

}

5188

}

5189

5190

public class NetClipboard : java.awt.datatransfer.Clipboard

5191

{

5192

public static readonly java.awt.datatransfer.FlavorTable flavorMap =

5193

(java.awt.datatransfer.FlavorTable)java.awt.datatransfer.SystemFlavorMap.getDefaultFlavorMap();

5194

5195

public NetClipboard() : base("System") { }

5196

5197

public override void setContents(java.awt.datatransfer.Transferable contents, java.awt.datatransfer.ClipboardOwner owner)

5198

{

5199

if (contents == null)

5200

{

5201

throw new java.lang.NullPointerException("contents");

5202

}

5203

5204

java.awt.datatransfer.ClipboardOwner oldOwner = this.owner;

5205

java.awt.datatransfer.Transferable oldContents = this.contents;

5206

try

5207

{

5208

this.owner = owner;

5209

this.contents = new sun.awt.datatransfer.TransferableProxy(contents, true);

5210

5211

setContentsNative(contents);

5212

}

5213

finally

5214

{

5215

if (oldOwner != null && oldOwner != owner)

5216

{

5217

java.awt.EventQueue.invokeLater(Delegates.toRunnable(delegate()

5218

{

5219

oldOwner.lostOwnership(this, oldContents);

5220

}));

5221

}

5222

}

5223

}

5224

5225

private void setContentsNative(java.awt.datatransfer.Transferable contents)

5226

{

5227

IDataObject clipObj = NetDataTransferer.getInstanceImpl().getDataObject(contents, flavorMap);

5228

NetToolkit.BeginInvoke(delegate

5229

{

5230

Clipboard.SetDataObject(clipObj, true);

5231

});

5232

}

5233

5234

public override java.awt.datatransfer.Transferable getContents(object requestor)

5235

{

5236

if (contents != null)

5237

{

5238

return contents;

5239

}

5240

return new NetClipboardTransferable(Clipboard.GetDataObject());

5241

}

5242

}

5243

5244

public class NetClipboardTransferable : java.awt.datatransfer.Transferable

5245

{

5246

private readonly Map flavorToData = new HashMap();

5247

private readonly java.awt.datatransfer.DataFlavor[] flavors;

5248

public NetClipboardTransferable(IDataObject data)

5249

{

5250

flavorToData = NetDataTransferer.getInstanceImpl().translateFromClipboard(data);

5251

flavors = (java.awt.datatransfer.DataFlavor[])flavorToData.keySet().toArray(new java.awt.datatransfer.DataFlavor[0]);

5252

}

5253

5254

public java.awt.datatransfer.DataFlavor[] getTransferDataFlavors()

5255

{

5256

return flavors;

5257

}

5258

public object getTransferData(java.awt.datatransfer.DataFlavor df)

5259

{

5260

return flavorToData.get(df);

5261

}

5262

5263

public bool isDataFlavorSupported(java.awt.datatransfer.DataFlavor df)

5264

{

5265

return flavorToData.containsKey(df);

5266

}

5267

}

5268

5269

public class NetDataTransferer : sun.awt.IkvmDataTransferer

5270

{

5271

class NetToolkitThreadBlockedHandler : sun.awt.datatransfer.ToolkitThreadBlockedHandler

5272

{

5273

private bool locked;

5274

private Thread owner;

5275

5276

protected bool isOwned()

5277

{

5278

return (locked && Thread.CurrentThread == owner);

5279

}

5280

5281

public void enter()

5282

{

5283

if (!isOwned())

5284

{

5285

throw new java.lang.IllegalMonitorStateException();

5286

}

5287

unlock();

5288

if (Application.MessageLoop)

5289

{

5290

Application.DoEvents();

5291

}

5292

@lock();

5293

}

5294

5295

public void exit()

5296

{

5297

if (!isOwned())

5298

{

5299

throw new java.lang.IllegalMonitorStateException();

5300

}

5301

}

5302

5303

public void @lock() {

5304

lock(this)

5305

{

5306

if (locked && Thread.CurrentThread == owner)

5307

{

5308

throw new java.lang.IllegalMonitorStateException();

5309

}

5310

5311

{

5312

if (!locked)

5313

{

5314

locked = true;

5315

owner = Thread.CurrentThread;

5316

}

5317

else

5318

{

5319

try

5320

{

5321

Monitor.Wait(this);

5322

}

5323

catch (ThreadInterruptedException)

5324

{

5325

// try again

5326

}

5327

}

5328

} while (owner != Thread.CurrentThread);

5329

}

5330

}

5331

5332

public void unlock()

5333

{

5334

lock (this)

5335

{

5336

if (Thread.CurrentThread != owner)

5337

{

5338

throw new java.lang.IllegalMonitorStateException();

5339

}

5340

owner = null;

5341

locked = false;

5342

Monitor.Pulse(this);

5343

}

5344

}

5345

}

5346

5347

5348

private static readonly NetDataTransferer instance = new NetDataTransferer();

5349

private static readonly NetToolkitThreadBlockedHandler handler = new NetToolkitThreadBlockedHandler();

5350

5351

public static NetDataTransferer getInstanceImpl()

5352

{

5353

return instance;

5354

}

5355

5356

internal long[] getClipboardFormatCodes(string[] formats)

5357

{

5358

long[] longData = new long[formats.Length];

5359

for(int i=0; i<formats.Length; i++)

5360

{

5361

DataFormats.Format dataFormat = DataFormats.GetFormat(formats[i]);

5362

longData[i] = dataFormat==null?0:dataFormat.Id;

5363

}

5364

return longData;

5365

}

5366

5367

internal string getNativeClipboardFormatName(long format)

5368

{

5369

DataFormats.Format dataFormat = DataFormats.GetFormat((int)format);

5370

if (dataFormat == null)

5371

return null;

5372

else

5373

return dataFormat.Name;

5374

}

5375

5376

internal Map translateFromClipboard(IDataObject data)

5377

{

5378

java.awt.datatransfer.FlavorTable defaultFlavorMap = (java.awt.datatransfer.FlavorTable)java.awt.datatransfer.SystemFlavorMap.getDefaultFlavorMap();

5379

Map/*<DataFlavor,object>*/ map = new HashMap();

5380

if (data == null)

5381

{

5382

return map;

5383

}

5384

string[] formats = data.GetFormats();

5385

if (formats != null && formats.Length > 0)

5386

{

5387

long[] longFormats = getClipboardFormatCodes(formats);

5388

Map /*<DataFlavor,long>*/ flavorMap = getFlavorsForFormats(longFormats, defaultFlavorMap);

5389

java.awt.datatransfer.DataFlavor[] flavors =

5390

(java.awt.datatransfer.DataFlavor[])

5391

(flavorMap.keySet().toArray(new java.awt.datatransfer.DataFlavor[0]));

5392

for(int i=0; i<flavors.Length; i++)

5393

{

5394

java.awt.datatransfer.DataFlavor df = flavors[i];

5395

long format = ((java.lang.Long) flavorMap.get(df)).longValue();

5396

string stringFormat = getNativeClipboardFormatName(format);

5397

if (stringFormat==null) continue; // clipboard format is not registered in Windows system

5398

object formatData = data.GetData(stringFormat);

5399

if (formatData == null) continue; // no data for that format

5400

object translatedData = null;

5401

if (df.isFlavorJavaFileListType())

5402

{

5403

// translate string[] into java.util.List<java.io.File>

5404

string[] nativeFileList = (string[])formatData;

5405

List fileList = new ArrayList(nativeFileList.Length);

5406

for (int j = 0; j < nativeFileList.Length; j++)

5407

{

5408

java.io.File file = new java.io.File(nativeFileList[i]);

5409

fileList.add(file);

5410

}

5411

translatedData = fileList;

5412

}

5413

else if (java.awt.datatransfer.DataFlavor.imageFlavor.equals(df) && formatData is Bitmap)

5414

{

5415

// translate System.Drawing.Bitmap into java.awt.Image

5416

translatedData = new java.awt.image.BufferedImage((Bitmap) formatData);

5417

}

5418

else if (formatData is string)

5419

{

5420

if (df.isFlavorTextType())

5421

translatedData = formatData;

5422

else if (((java.lang.Class)typeof(java.io.Reader)).equals(df.getRepresentationClass()))

5423

translatedData = new java.io.StringReader((string) formatData);

5424

else if (((java.lang.Class)typeof(java.io.InputStream)).equals(df.getRepresentationClass()))

5425

translatedData = new java.io.StringBufferInputStream((string)formatData);

5426

else

5427

throw new java.awt.datatransfer.UnsupportedFlavorException(df);

5428

}

5429

if (translatedData!=null)

5430

map.put(df, translatedData);

5431

}

5432

}

5433

return map;

5434

}

5435

5436

internal IDataObject getDataObject(java.awt.datatransfer.Transferable transferable, java.awt.datatransfer.FlavorTable flavorMap)

5437

{

5438

DataObject obj = new DataObject();

5439

SortedMap/*<java.lang.Long,java.awt.datatransfer.DataFlavor>*/ formatMap = getFormatsForTransferable(transferable, flavorMap);

5440

for (Iterator iterator = formatMap.entrySet().iterator(); iterator.hasNext();)

5441

{

5442

Map.Entry entry = (Map.Entry) iterator.next();

5443

java.lang.Long lFormat = (java.lang.Long) entry.getKey();

5444

long format = lFormat == null ? -1 : lFormat.longValue();

5445

java.awt.datatransfer.DataFlavor flavor = (java.awt.datatransfer.DataFlavor) entry.getValue();

5446

object contents = transferable.getTransferData(flavor);

5447

if (contents==null) continue;

5448

try

5449

{

5450

if (java.awt.datatransfer.DataFlavor.javaFileListFlavor.equals(flavor))

5451

{

5452

List list = (List)contents;

5453

System.Collections.Specialized.StringCollection files =

5454

new System.Collections.Specialized.StringCollection();

5455

for (int i = 0; i < list.size(); i++)

5456

{

5457

files.Add(((java.io.File) list.get(i)).getAbsolutePath());

5458

}

5459

obj.SetFileDropList(files);

5460

}

5461

else if (flavor.isFlavorTextType())

5462

{

5463

if (contents is string)

5464

obj.SetText((string) transferable.getTransferData(flavor));

5465

}

5466

else if (java.awt.datatransfer.DataFlavor.imageFlavor.equals(flavor))

5467

{

5468

java.awt.Image image = contents as java.awt.Image;

5469

if (image != null)

5470

{

5471

Image netImage = J2C.ConvertImage(image);

5472

if (netImage != null)

5473

{

5474

obj.SetImage(netImage);

5475

}

5476

}

5477

}

5478

else if (flavor.isRepresentationClassCharBuffer())

5479

{

5480

if (!(isFlavorCharsetTextType(flavor) && isTextFormat(format)))

5481

{

5482

throw new IOException("cannot transfer non-text data as CharBuffer");

5483

}

5484

java.nio.CharBuffer buffer = (java.nio.CharBuffer)contents;

5485

int size = buffer.remaining();

5486

char[] chars = new char[size];

5487

buffer.get(chars, 0, size);

5488

obj.SetText(new string(chars));

5489

}

5490

else

5491

{

5492

// don't know what to do with it...

5493

obj.SetData(transferable.getTransferData(flavor));

5494

}

5495

}

5496

catch (java.io.IOException e)

5497

{

5498

if (!(flavor.isMimeTypeEqual(java.awt.datatransfer.DataFlavor.javaJVMLocalObjectMimeType) &&

5499

e is java.io.NotSerializableException))

5500

{

5501

e.printStackTrace();

5502

}

5503

}

5504

}

5505

return obj;

5506

}

5507

5508

protected override string getClipboardFormatName(long format)

5509

{

5510

return getNativeClipboardFormatName(format);

5511

}

5512

5513

protected override byte[] imageToStandardBytes(java.awt.Image image, string mimeType)

5514

{

5515

if (image is NoImage) return null;

5516

Image netImage = J2C.ConvertImage(image);

5517

ImageFormat format;

5518

switch(mimeType)

5519

{

5520

case "image/jpg":

5521

case "image/jpeg":

5522

format = ImageFormat.Jpeg;

5523

break;

5524

case "image/png":

5525

format = ImageFormat.Png;

5526

break;

5527

case "image/gif":

5528

format = ImageFormat.Gif;

5529

break;

5530

case "image/x-win-metafile":

5531

case "image/x-wmf":

5532

case "image/wmf":

5533

format = ImageFormat.Wmf;

5534

break;

5535

default:

5536

return null;

5537

}

5538

using(MemoryStream stream = new MemoryStream())

5539

{

5540

netImage.Save(stream, format);

5541

return stream.GetBuffer();

5542

}

5543

}

5544

5545

public override sun.awt.datatransfer.ToolkitThreadBlockedHandler getToolkitThreadBlockedHandler()

5546

{

5547

return handler;

5548

}

5549

5550

protected override java.io.ByteArrayOutputStream convertFileListToBytes(java.util.ArrayList fileList)

5551

{

5552

throw new ikvm.@internal.NotYetImplementedError();

5553

}

5554

}

5555

5556

}

Older »