browser_delegates.hpp

// Copyright (c) 2000-2023 TeamDev Ltd. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_BROWSER_DELEGATES_HPP
#define MOLYBDEN_BROWSER_DELEGATES_HPP
 
#include <memory>
#include <vector>
 
#include "molybden/base/delegate.hpp"
#include "molybden/base/delegate_action.hpp"
#include "molybden/browser/browser_command.hpp"
#include "molybden/browser/input_events.hpp"
#include "molybden/capture/capture_sources.hpp"
#include "molybden/card/credit_card.hpp"
#include "molybden/js/js_object.hpp"
#include "molybden/menu/context_menu.hpp"
#include "molybden/menu/menu.hpp"
#include "molybden/network/network.hpp"
#include "molybden/network/tls/certificate.hpp"
#include "molybden/ui/geometry.hpp"
#include "molybden/user/user_profile.hpp"
 
namespace molybden {
 
class Frame;
class Browser;
class Download;
 
enum class MediaType;
 
struct HostPort;
 
struct InjectJsArgs {
  std::shared_ptr<Browser> browser;
 
  std::shared_ptr<Frame> frame;
 
  std::shared_ptr<JsObject> window;
};
 
class InjectJsAction : public Action {
 public:
  explicit InjectJsAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
};
 
struct InjectCssArgs {
  std::shared_ptr<Browser> browser;
 
  std::shared_ptr<Frame> frame;
};
 
class InjectCssAction : public Action {
 public:
  explicit InjectCssAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void inject(const std::string& css);
 
  void proceed();
};
 
struct CertErrorArgs {
  std::shared_ptr<Browser> browser;
 
  NetError error;
 
  std::string url;
 
  bool is_main_frame;
 
  Certificate certificate;
};
 
class CertErrorAction : public Action {
 public:
  explicit CertErrorAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void ignore();
 
  void showErrorPage();
};
 
struct VerifyCertArgs {
  std::shared_ptr<Browser> browser;
 
  std::string host;
 
  Certificate certificate;
 
  std::vector<Certificate> intermediate_certs;
 
  std::vector<CertVerificationError> verification_errors;
};
 
class VerifyCertAction : public Action {
 public:
  explicit VerifyCertAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void valid();
 
  void invalid(const std::vector<CertVerificationStatus>& statuses);
 
  void defaultAction();
};
 
struct EnterMouseArgs {
  std::shared_ptr<Browser> browser;
 
  MouseEntered event;
};
 
class EnterMouseAction : public Action {
 public:
  explicit EnterMouseAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct ExitMouseArgs {
  std::shared_ptr<Browser> browser;
 
  MouseExited event;
};
 
class ExitMouseAction : public Action {
 public:
  explicit ExitMouseAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct MoveMouseArgs {
  std::shared_ptr<Browser> browser;
 
  MouseMoved event;
};
 
class MoveMouseAction : public Action {
 public:
  explicit MoveMouseAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct MoveMouseWheelArgs {
  std::shared_ptr<Browser> browser;
 
  MouseWheel event;
};
 
class MoveMouseWheelAction : public Action {
 public:
  explicit MoveMouseWheelAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct PressMouseArgs {
  std::shared_ptr<Browser> browser;
 
  MousePressed event;
};
 
class PressMouseAction : public Action {
 public:
  explicit PressMouseAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct ReleaseMouseArgs {
  std::shared_ptr<Browser> browser;
 
  MouseReleased event;
};
 
class ReleaseMouseAction : public Action {
 public:
  explicit ReleaseMouseAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct PressKeyArgs {
  std::shared_ptr<Browser> browser;
 
  KeyPressed event;
};
 
class PressKeyAction : public Action {
 public:
  explicit PressKeyAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct ReleaseKeyArgs {
  std::shared_ptr<Browser> browser;
 
  KeyReleased event;
};
 
class ReleaseKeyAction : public Action {
 public:
  explicit ReleaseKeyAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct TypeKeyArgs {
  std::shared_ptr<Browser> browser;
 
  KeyTyped event;
};
 
class TypeKeyAction : public Action {
 public:
  explicit TypeKeyAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void proceed();
 
  void suppress();
};
 
struct OpenPopupArgs {
  std::shared_ptr<Browser> browser;
 
  std::shared_ptr<Browser> popup_browser;
 
  std::string target_name;
 
  std::string target_url;
 
  Rect initial_bounds;
 
  float scale_factor;
};
 
class OpenPopupAction : public Action {
 public:
  explicit OpenPopupAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void open();
 
  void close();
};
 
struct ShowContextMenuArgs {
  std::shared_ptr<Browser> browser;
 
  std::string link_url;
 
  std::string link_text;
 
  std::string src_url;
 
  std::string page_url;
 
  std::string frame_url;
 
  std::string selected_text;
 
  ContextMenuContentType content_type;
};
 
class ShowContextMenuAction : public Action {
 public:
  explicit ShowContextMenuAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void show(std::shared_ptr<CustomContextMenu> context_menu);
};
 
struct AlertArgs {
  std::shared_ptr<Browser> browser;
 
  std::string title;
 
  std::string message;
 
  std::string ok_action_text;
 
  std::string url;
};
 
class AlertAction : public Action {
 public:
  explicit AlertAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void prompt();
 
  void ok();
};
 
struct ConfirmArgs {
  std::shared_ptr<Browser> browser;
 
  std::string title;
 
  std::string message;
 
  std::string ok_action_text;
 
  std::string cancel_action_text;
 
  std::string url;
};
 
class ConfirmAction : public Action {
 public:
  explicit ConfirmAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void prompt();
 
  void ok();
 
  void cancel();
};
 
struct PromptArgs {
  std::shared_ptr<Browser> browser;
 
  std::string title;
 
  std::string message;
 
  std::string ok_action_text;
 
  std::string cancel_action_text;
};
 
class PromptAction : public Action {
 public:
  explicit PromptAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void prompt();
 
  void ok(const std::string& text);
 
  void cancel();
};
 
struct BeforeUnloadArgs {
  std::shared_ptr<Browser> browser;
 
  std::string title;
 
  std::string message;
 
  std::string stay_action_text;
 
  std::string leave_action_text;
 
  bool is_reload;
};
 
class BeforeUnloadAction : public Action {
 public:
  explicit BeforeUnloadAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void prompt();
 
  void stay();
 
  void leave();
};
 
struct BeforeFormRepostArgs {
  std::shared_ptr<Browser> browser;
 
  std::string title;
 
  std::string message;
 
  std::string repost_action_text;
 
  std::string cancel_action_text;
};
 
class BeforeFormRepostAction : public Action {
 public:
  explicit BeforeFormRepostAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void repost();
 
  void cancel();
 
  void prompt();
};
 
struct SaveAsPdfArgs {
  std::shared_ptr<Browser> browser;
 
  std::string suggested_file_name;
 
  std::string suggested_directory_path;
};
 
class SaveAsPdfAction : public Action {
 public:
  explicit SaveAsPdfAction(std::unique_ptr<rpc::internal::Callback> callback);
 
  void save(const std::string& file_path);
 
  void cancel();
 
  void prompt();
};
 
struct CanExecuteCommandArgs {
  std::shared_ptr<Browser> browser;
 
  BrowserCommandId command_id;
};
 
class CanExecuteCommandAction : public Action {
 public:
  explicit CanExecuteCommandAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void can();
 
  void cannot();
};
 
struct StartDownloadArgs {
  std::shared_ptr<Browser> browser;
 
  std::shared_ptr<Frame> frame;
 
  std::shared_ptr<Download> download;
};
 
class StartDownloadAction : public Action {
 public:
  explicit StartDownloadAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void download(const std::string& file_path);
 
  void cancel();
 
  void prompt();
};
 
struct SavePasswordArgs {
  std::shared_ptr<Browser> browser;
 
  std::string url;
 
  std::string login;
};
 
class SavePasswordAction : public Action {
 public:
  explicit SavePasswordAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void save();
 
  void neverSave();
 
  void cancel();
 
  void prompt();
};
 
struct UpdatePasswordArgs {
  std::shared_ptr<Browser> browser;
 
  std::string url;
 
  std::string login;
};
 
class UpdatePasswordAction : public Action {
 public:
  explicit UpdatePasswordAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void update();
 
  void cancel();
 
  void prompt();
};
 
struct AuthenticateArgs {
  std::shared_ptr<Browser> browser;
 
  std::string url;
 
  std::string scheme;
 
  HostPort host_port;
 
  bool is_proxy;
};
 
class AuthenticateAction : public Action {
 public:
  explicit AuthenticateAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void authenticate(const std::string& user_name, const std::string& password);
 
  void cancel();
 
  void prompt();
};
 
struct RequestPdfPasswordArgs {
  std::shared_ptr<Browser> browser;
 
  std::shared_ptr<Frame> frame;
 
  std::string url;
};
 
class RequestPdfPasswordAction : public Action {
 public:
  explicit RequestPdfPasswordAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void password(const std::string& password);
 
  void cancel();
 
  void prompt();
};
 
struct StartCaptureSessionArgs {
  std::shared_ptr<Browser> browser;
 
  std::shared_ptr<Frame> frame;
 
  std::string url;
 
  CaptureSources sources;
 
  bool audio_capture_requested;
};
 
class StartCaptureSessionAction : public Action {
 public:
  explicit StartCaptureSessionAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void selectSource(const CaptureSource& source, bool capture_audio);
 
  void selectSource(std::shared_ptr<Browser> browser, bool capture_audio);
 
  void cancel();
 
  void prompt();
};
 
struct SaveCreditCardArgs {
  std::shared_ptr<Browser> browser;
 
  CreditCard credit_card;
};
 
class SaveCreditCardAction : public Action {
 public:
  explicit SaveCreditCardAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void save();
 
  void cancel();
 
  void prompt();
};
 
struct SaveUserProfileArgs {
  std::shared_ptr<Browser> browser;
 
  UserProfile user_profile;
};
 
class SaveUserProfileAction : public Action {
 public:
  explicit SaveUserProfileAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void save();
 
  void cancel();
 
  void prompt();
};
 
struct UpdateUserProfileArgs {
  std::shared_ptr<Browser> browser;
 
  UserProfile user_profile;
 
  UserProfile original_user_profile;
};
 
class UpdateUserProfileAction : public Action {
 public:
  explicit UpdateUserProfileAction(
      std::unique_ptr<rpc::internal::Callback> callback);
 
  void update();
 
  void cancel();
 
  void prompt();
};
 
class BrowserDelegates {
 public:
  Delegate<InjectJsArgs, InjectJsAction> onInjectJs;
 
  Delegate<InjectCssArgs, InjectCssAction> onInjectCss;
 
  Delegate<CertErrorArgs, CertErrorAction> onCertError;
 
  Delegate<VerifyCertArgs, VerifyCertAction> onVerifyCert;
 
  Delegate<PressKeyArgs, PressKeyAction> onPressKey;
 
  Delegate<ReleaseKeyArgs, ReleaseKeyAction> onReleaseKey;
 
  Delegate<TypeKeyArgs, TypeKeyAction> onTypeKey;
 
  Delegate<EnterMouseArgs, EnterMouseAction> onEnterMouse;
  Delegate<ExitMouseArgs, ExitMouseAction> onExitMouse;
 
  Delegate<MoveMouseArgs, MoveMouseAction> onMoveMouse;
 
  Delegate<ReleaseMouseArgs, ReleaseMouseAction> onReleaseMouse;
 
  Delegate<PressMouseArgs, PressMouseAction> onPressMouse;
 
  Delegate<MoveMouseWheelArgs, MoveMouseWheelAction> onMoveMouseWheel;
 
  Delegate<OpenPopupArgs, OpenPopupAction> onOpenPopup;
 
  Delegate<ShowContextMenuArgs, ShowContextMenuAction> onShowContextMenu;
 
  Delegate<AlertArgs, AlertAction> onAlert;
 
  Delegate<ConfirmArgs, ConfirmAction> onConfirm;
 
  Delegate<PromptArgs, PromptAction> onPrompt;
 
  Delegate<BeforeUnloadArgs, BeforeUnloadAction> onBeforeUnload;
 
  Delegate<BeforeFormRepostArgs, BeforeFormRepostAction> onBeforeFormRepost;
 
  Delegate<SaveAsPdfArgs, SaveAsPdfAction> onSaveAsPdf;
 
  Delegate<CanExecuteCommandArgs, CanExecuteCommandAction> onCanExecuteCommand;
 
  Delegate<StartDownloadArgs, StartDownloadAction> onStartDownload;
 
  Delegate<SavePasswordArgs, SavePasswordAction> onSavePassword;
 
  Delegate<UpdatePasswordArgs, UpdatePasswordAction> onUpdatePassword;
 
  Delegate<AuthenticateArgs, AuthenticateAction> onAuthenticate;
 
  Delegate<RequestPdfPasswordArgs, RequestPdfPasswordAction>
      onRequestPdfPassword;
 
  Delegate<StartCaptureSessionArgs, StartCaptureSessionAction>
      onStartCaptureSession;
 
  Delegate<SaveCreditCardArgs, SaveCreditCardAction> onSaveCreditCard;
 
  Delegate<SaveUserProfileArgs, SaveUserProfileAction> onSaveUserProfile;
 
  Delegate<UpdateUserProfileArgs, UpdateUserProfileAction> onUpdateUserProfile;
};
 
}  // namespace molybden
 
#endif  // MOLYBDEN_BROWSER_DELEGATES_HPP