int-test mqtt <-> prediction
This commit is contained in:
naumueller
@@ -0,0 +1,229 @@
|
||||
// Copyright (c) 2014 The Chromium Embedded Framework Authors. All rights
|
||||
// reserved. Use of this source code is governed by a BSD-style license that
|
||||
// can be found in the LICENSE file.
|
||||
|
||||
package tests.simple;
|
||||
|
||||
import org.cef.CefApp;
|
||||
import org.cef.CefApp.CefAppState;
|
||||
import org.cef.CefClient;
|
||||
import org.cef.CefSettings;
|
||||
import org.cef.OS;
|
||||
import org.cef.browser.CefBrowser;
|
||||
import org.cef.browser.CefFrame;
|
||||
import org.cef.handler.CefAppHandlerAdapter;
|
||||
import org.cef.handler.CefDisplayHandlerAdapter;
|
||||
import org.cef.handler.CefFocusHandlerAdapter;
|
||||
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Component;
|
||||
import java.awt.GraphicsConfiguration;
|
||||
import java.awt.KeyboardFocusManager;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
import java.awt.event.FocusAdapter;
|
||||
import java.awt.event.FocusEvent;
|
||||
import java.awt.event.WindowAdapter;
|
||||
import java.awt.event.WindowEvent;
|
||||
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JTextField;
|
||||
import javax.swing.SwingUtilities;
|
||||
|
||||
/**
|
||||
* This is a simple example application using JCEF.
|
||||
* It displays a JFrame with a JTextField at its top and a CefBrowser in its
|
||||
* center. The JTextField is used to enter and assign an URL to the browser UI.
|
||||
* No additional handlers or callbacks are used in this example.
|
||||
*
|
||||
* The number of used JCEF classes is reduced (nearly) to its minimum and should
|
||||
* assist you to get familiar with JCEF.
|
||||
*
|
||||
* For a more feature complete example have also a look onto the example code
|
||||
* within the package "tests.detailed".
|
||||
*/
|
||||
public class MainFrame extends JFrame {
|
||||
private static final long serialVersionUID = -5570653778104813836L;
|
||||
private final JTextField address_;
|
||||
private final CefApp cefApp_;
|
||||
private final CefClient client_;
|
||||
private final CefBrowser browser_;
|
||||
private final Component browserUI_;
|
||||
private boolean browserFocus_ = true;
|
||||
private JFrame fullscreenFrame_;
|
||||
|
||||
/**
|
||||
* To display a simple browser window, it suffices completely to create an
|
||||
* instance of the class CefBrowser and to assign its UI component to your
|
||||
* application (e.g. to your content pane).
|
||||
* But to be more verbose, this CTOR keeps an instance of each object on the
|
||||
* way to the browser UI.
|
||||
*/
|
||||
private MainFrame(String startURL, boolean useOSR, boolean isTransparent) {
|
||||
// (1) The entry point to JCEF is always the class CefApp. There is only one
|
||||
// instance per application and therefore you have to call the method
|
||||
// "getInstance()" instead of a CTOR.
|
||||
//
|
||||
// CefApp is responsible for the global CEF context. It loads all
|
||||
// required native libraries, initializes CEF accordingly, starts a
|
||||
// background task to handle CEF's message loop and takes care of
|
||||
// shutting down CEF after disposing it.
|
||||
CefApp.addAppHandler(new CefAppHandlerAdapter(null) {
|
||||
@Override
|
||||
public void stateHasChanged(org.cef.CefApp.CefAppState state) {
|
||||
// Shutdown the app if the native CEF part is terminated
|
||||
if (state == CefAppState.TERMINATED) System.exit(0);
|
||||
}
|
||||
});
|
||||
CefSettings settings = new CefSettings();
|
||||
settings.windowless_rendering_enabled = useOSR;
|
||||
cefApp_ = CefApp.getInstance(settings);
|
||||
|
||||
// (2) JCEF can handle one to many browser instances simultaneous. These
|
||||
// browser instances are logically grouped together by an instance of
|
||||
// the class CefClient. In your application you can create one to many
|
||||
// instances of CefClient with one to many CefBrowser instances per
|
||||
// client. To get an instance of CefClient you have to use the method
|
||||
// "createClient()" of your CefApp instance. Calling an CTOR of
|
||||
// CefClient is not supported.
|
||||
//
|
||||
// CefClient is a connector to all possible events which come from the
|
||||
// CefBrowser instances. Those events could be simple things like the
|
||||
// change of the browser title or more complex ones like context menu
|
||||
// events. By assigning handlers to CefClient you can control the
|
||||
// behavior of the browser. See tests.detailed.MainFrame for an example
|
||||
// of how to use these handlers.
|
||||
client_ = cefApp_.createClient();
|
||||
|
||||
// (3) One CefBrowser instance is responsible to control what you'll see on
|
||||
// the UI component of the instance. It can be displayed off-screen
|
||||
// rendered or windowed rendered. To get an instance of CefBrowser you
|
||||
// have to call the method "createBrowser()" of your CefClient
|
||||
// instances.
|
||||
//
|
||||
// CefBrowser has methods like "goBack()", "goForward()", "loadURL()",
|
||||
// and many more which are used to control the behavior of the displayed
|
||||
// content. The UI is held within a UI-Compontent which can be accessed
|
||||
// by calling the method "getUIComponent()" on the instance of CefBrowser.
|
||||
// The UI component is inherited from a java.awt.Component and therefore
|
||||
// it can be embedded into any AWT UI.
|
||||
browser_ = client_.createBrowser(startURL, useOSR, isTransparent);
|
||||
browserUI_ = browser_.getUIComponent();
|
||||
|
||||
// (4) For this minimal browser, we need only a text field to enter an URL
|
||||
// we want to navigate to and a CefBrowser window to display the content
|
||||
// of the URL. To respond to the input of the user, we're registering an
|
||||
// anonymous ActionListener. This listener is performed each time the
|
||||
// user presses the "ENTER" key within the address field.
|
||||
// If this happens, the entered value is passed to the CefBrowser
|
||||
// instance to be loaded as URL.
|
||||
address_ = new JTextField(startURL, 100);
|
||||
address_.addActionListener(new ActionListener() {
|
||||
@Override
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
browser_.loadURL(address_.getText());
|
||||
}
|
||||
});
|
||||
|
||||
// Update the address field when the browser URL changes.
|
||||
client_.addDisplayHandler(new CefDisplayHandlerAdapter() {
|
||||
@Override
|
||||
public void onAddressChange(CefBrowser browser, CefFrame frame, String url) {
|
||||
address_.setText(url);
|
||||
}
|
||||
@Override
|
||||
public void onFullscreenModeChange(CefBrowser browser, boolean fullscreen) {
|
||||
setBrowserFullscreen(fullscreen);
|
||||
}
|
||||
});
|
||||
|
||||
// Clear focus from the browser when the address field gains focus.
|
||||
address_.addFocusListener(new FocusAdapter() {
|
||||
@Override
|
||||
public void focusGained(FocusEvent e) {
|
||||
if (!browserFocus_) return;
|
||||
browserFocus_ = false;
|
||||
KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
|
||||
address_.requestFocus();
|
||||
}
|
||||
});
|
||||
|
||||
// Clear focus from the address field when the browser gains focus.
|
||||
client_.addFocusHandler(new CefFocusHandlerAdapter() {
|
||||
@Override
|
||||
public void onGotFocus(CefBrowser browser) {
|
||||
if (browserFocus_) return;
|
||||
browserFocus_ = true;
|
||||
KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
|
||||
browser.setFocus(true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onTakeFocus(CefBrowser browser, boolean next) {
|
||||
browserFocus_ = false;
|
||||
}
|
||||
});
|
||||
|
||||
// (5) All UI components are assigned to the default content pane of this
|
||||
// JFrame and afterwards the frame is made visible to the user.
|
||||
getContentPane().add(address_, BorderLayout.NORTH);
|
||||
getContentPane().add(browserUI_, BorderLayout.CENTER);
|
||||
pack();
|
||||
setSize(800, 600);
|
||||
setVisible(true);
|
||||
|
||||
// (6) To take care of shutting down CEF accordingly, it's important to call
|
||||
// the method "dispose()" of the CefApp instance if the Java
|
||||
// application will be closed. Otherwise you'll get asserts from CEF.
|
||||
addWindowListener(new WindowAdapter() {
|
||||
@Override
|
||||
public void windowClosing(WindowEvent e) {
|
||||
CefApp.getInstance().dispose();
|
||||
dispose();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void setBrowserFullscreen(boolean fullscreen) {
|
||||
SwingUtilities.invokeLater(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
if (fullscreen) {
|
||||
if (fullscreenFrame_ == null) {
|
||||
fullscreenFrame_ = new JFrame();
|
||||
fullscreenFrame_.setUndecorated(true);
|
||||
fullscreenFrame_.setResizable(true);
|
||||
}
|
||||
GraphicsConfiguration gc = MainFrame.this.getGraphicsConfiguration();
|
||||
fullscreenFrame_.setBounds(gc.getBounds());
|
||||
gc.getDevice().setFullScreenWindow(fullscreenFrame_);
|
||||
|
||||
getContentPane().remove(browserUI_);
|
||||
fullscreenFrame_.add(browserUI_);
|
||||
fullscreenFrame_.setVisible(true);
|
||||
fullscreenFrame_.validate();
|
||||
} else {
|
||||
fullscreenFrame_.remove(browserUI_);
|
||||
fullscreenFrame_.setVisible(false);
|
||||
getContentPane().add(browserUI_, BorderLayout.CENTER);
|
||||
getContentPane().validate();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
// Perform startup initialization on platforms that require it.
|
||||
if (!CefApp.startup(args)) {
|
||||
System.out.println("Startup initialization failed!");
|
||||
return;
|
||||
}
|
||||
|
||||
// The simple example application is created as anonymous class and points
|
||||
// to Google as the very first loaded page. Windowed rendering mode is used by
|
||||
// default. If you want to test OSR mode set |useOsr| to true and recompile.
|
||||
boolean useOsr = false;
|
||||
new MainFrame("http://www.google.com", useOsr, false);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user