EntangleCamera

EntangleCamera

Synopsis

struct              EntangleCamera;
struct              EntangleCameraClass;
EntangleCamera *    entangle_camera_new                 (const char *model,
                                                         const char *port,
                                                         gboolean hasCapture,
                                                         gboolean hasPreview,
                                                         gboolean hasSettings);
const char *        entangle_camera_get_model           (EntangleCamera *cam);
const char *        entangle_camera_get_port            (EntangleCamera *cam);
gboolean            entangle_camera_connect             (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_connect_async       (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_connect_finish      (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_disconnect          (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_disconnect_async    (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_disconnect_finish   (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_get_connected       (EntangleCamera *cam);
char *              entangle_camera_get_summary         (EntangleCamera *cam);
char *              entangle_camera_get_manual          (EntangleCamera *cam);
char *              entangle_camera_get_driver          (EntangleCamera *cam);
EntangleCameraFile * entangle_camera_capture_image      (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_capture_image_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
EntangleCameraFile * entangle_camera_capture_image_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
EntangleCameraFile * entangle_camera_preview_image      (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_preview_image_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
EntangleCameraFile * entangle_camera_preview_image_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_download_file       (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GError **error);
void                entangle_camera_download_file_async (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_download_file_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **err);
gboolean            entangle_camera_delete_file         (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GError **error);
void                entangle_camera_delete_file_async   (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_delete_file_finish  (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_process_events      (EntangleCamera *cam,
                                                         guint64 waitms,
                                                         GError **error);
void                entangle_camera_process_events_async
                                                        (EntangleCamera *cam,
                                                         guint64 waitms,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_process_events_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_set_viewfinder      (EntangleCamera *cam,
                                                         gboolean enabled,
                                                         GError **error);
void                entangle_camera_set_viewfinder_async
                                                        (EntangleCamera *cam,
                                                         gboolean enabled,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_set_viewfinder_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_autofocus           (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_autofocus_async     (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_autofocus_finish    (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
enum                EntangleCameraManualFocusStep;
gboolean            entangle_camera_manualfocus         (EntangleCamera *cam,
                                                         EntangleCameraManualFocusStep step,
                                                         GError **error);
void                entangle_camera_manualfocus_async   (EntangleCamera *cam,
                                                         EntangleCameraManualFocusStep step,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_manualfocus_finish  (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_set_clock           (EntangleCamera *cam,
                                                         gint64 epochsecs,
                                                         GError **error);
void                entangle_camera_set_clock_async     (EntangleCamera *cam,
                                                         gint64 epochsecs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_set_clock_finish    (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
enum                EntangleCameraCaptureTarget;
gboolean            entangle_camera_set_capture_target  (EntangleCamera *cam,
                                                         EntangleCameraCaptureTarget target,
                                                         GError **error);
void                entangle_camera_set_capture_target_async
                                                        (EntangleCamera *cam,
                                                         EntangleCameraCaptureTarget target,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_set_capture_target_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_get_has_capture     (EntangleCamera *cam);
gboolean            entangle_camera_get_has_preview     (EntangleCamera *cam);
gboolean            entangle_camera_get_has_settings    (EntangleCamera *cam);
gboolean            entangle_camera_get_has_viewfinder  (EntangleCamera *cam);
gboolean            entangle_camera_load_controls       (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_load_controls_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_load_controls_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            entangle_camera_save_controls       (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_save_controls_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_save_controls_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);
EntangleControlGroup * entangle_camera_get_controls     (EntangleCamera *cam,
                                                         GError **error);
void                entangle_camera_set_progress        (EntangleCamera *cam,
                                                         EntangleProgress *prog);
EntangleProgress *  entangle_camera_get_progress        (EntangleCamera *cam);
gboolean            entangle_camera_is_mounted          (EntangleCamera *cam);
void                entangle_camera_mount_async         (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_mount_finish        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **err);
void                entangle_camera_unmount_async       (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            entangle_camera_unmount_finish      (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **err);

Object Hierarchy

  GObject
   +----EntangleCamera
  GEnum
   +----EntangleCameraManualFocusStep
  GEnum
   +----EntangleCameraCaptureTarget

Properties

  "driver"                   gchar*                : Read
  "has-capture"              gboolean              : Read / Write / Construct Only
  "has-preview"              gboolean              : Read / Write / Construct Only
  "has-settings"             gboolean              : Read / Write / Construct Only
  "has-viewfinder"           gboolean              : Read / Write / Construct Only
  "manual"                   gchar*                : Read
  "model"                    gchar*                : Read / Write / Construct Only
  "port"                     gchar*                : Read / Write / Construct Only
  "progress"                 EntangleProgress*     : Read / Write
  "summary"                  gchar*                : Read

Signals

  "camera-connected"                               : Run First
  "camera-controls-changed"                        : Run First
  "camera-disconnected"                            : Run First
  "camera-file-added"                              : Run First
  "camera-file-captured"                           : Run First
  "camera-file-deleted"                            : Run First
  "camera-file-downloaded"                         : Run First
  "camera-file-previewed"                          : Run First

Description

Details

struct EntangleCamera

struct EntangleCamera;

struct EntangleCameraClass

struct EntangleCameraClass {
    GObjectClass parent_class;

    void (*camera_file_added)(EntangleCamera *cam, EntangleCameraFile *file);
    void (*camera_file_captured)(EntangleCamera *cam, EntangleCameraFile *file);
    void (*camera_file_previewed)(EntangleCamera *cam, EntangleCameraFile *file);
    void (*camera_file_downloaded)(EntangleCamera *cam, EntangleCameraFile *file);
    void (*camera_file_deleted)(EntangleCamera *cam, EntangleCameraFile *file);

    void (*camera_controls_changed)(EntangleCamera *cam);

    void (*camera_connected)(EntangleCamera *cam);
    void (*camera_disconnected)(EntangleCamera *cam);
};

entangle_camera_new ()

EntangleCamera *    entangle_camera_new                 (const char *model,
                                                         const char *port,
                                                         gboolean hasCapture,
                                                         gboolean hasPreview,
                                                         gboolean hasSettings);

entangle_camera_get_model ()

const char *        entangle_camera_get_model           (EntangleCamera *cam);

Get the camera model name

cam :

the camera. [transfer none]

Returns :

the model name. [transfer none]

entangle_camera_get_port ()

const char *        entangle_camera_get_port            (EntangleCamera *cam);

Get the camera port name

cam :

the camera. [transfer none]

Returns :

the port name. [transfer none]

entangle_camera_connect ()

gboolean            entangle_camera_connect             (EntangleCamera *cam,
                                                         GError **error);

Attempt to connect to and initialize the camera. This may fail if the camera is in use by another application, has gone to sleep or has been disconnected from the port.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is connected, FALSE on error

entangle_camera_connect_async ()

void                entangle_camera_connect_async       (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Attempt to connect to and initialize the camera. This may fail if the camera is in use by another application, has gone to sleep or has been disconnected from the port.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_connect_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_connect_finish ()

gboolean            entangle_camera_connect_finish      (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_connect_async

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is connected, FALSE on error

entangle_camera_disconnect ()

gboolean            entangle_camera_disconnect          (EntangleCamera *cam,
                                                         GError **error);

Disconnect from the camera, enabling it to be used by other applications.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is disconnected, FALSE on error

entangle_camera_disconnect_async ()

void                entangle_camera_disconnect_async    (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Disconnect from the camera, enabling it to be used by other applications.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_connect_async can be used to check the status

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is disconnected, FALSE on error

entangle_camera_disconnect_finish ()

gboolean            entangle_camera_disconnect_finish   (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_disconnect_async

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is disconnected, FALSE on error

entangle_camera_get_connected ()

gboolean            entangle_camera_get_connected       (EntangleCamera *cam);

Determine if the camera is currently connected

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is connected, FALSE otherwise

entangle_camera_get_summary ()

char *              entangle_camera_get_summary         (EntangleCamera *cam);

Get the camera summary text. This is only available while the camera is connected

cam :

the camera. [transfer none]

Returns :

the camera summary. [transfer full]

entangle_camera_get_manual ()

char *              entangle_camera_get_manual          (EntangleCamera *cam);

Get the camera manual text. This is only available while the camera is connected

cam :

the camera. [transfer none]

Returns :

the camera manual. [transfer full]

entangle_camera_get_driver ()

char *              entangle_camera_get_driver          (EntangleCamera *cam);

Get the camera driver information text. This is only available while the camera is connected

cam :

the camera. [transfer none]

Returns :

the camera driver information. [transfer full]

entangle_camera_capture_image ()

EntangleCameraFile * entangle_camera_capture_image      (EntangleCamera *cam,
                                                         GError **error);

Trigger the camera shutter and download the first resulting image. If the camera is shooting in multiple formats (eg JPEG and RAW) this method will only return the first format captured The caller should watch for signal notifications to detect any additional images

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

the captured image or NULL. [transfer full]

entangle_camera_capture_image_async ()

void                entangle_camera_capture_image_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Trigger the camera shutter and download the first resulting image. If the camera is shooting in multiple formats (eg JPEG and RAW) this method will only return the first format captured The caller should watch for signal notifications to detect any additional images

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_capture_image_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_capture_image_finish ()

EntangleCameraFile * entangle_camera_capture_image_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_capture_image_async.

cam :

the camera. [transfer none]

Returns :

the captured image or NULL. [transfer full]

entangle_camera_preview_image ()

EntangleCameraFile * entangle_camera_preview_image      (EntangleCamera *cam,
                                                         GError **error);

Enable "live view", if not already enabled, and capture a low resolution preview image. The "live view" mode will remain enabled after execution.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

the captured image or NULL. [transfer full]

entangle_camera_preview_image_async ()

void                entangle_camera_preview_image_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Enable "live view", if not already enabled, and capture a low resolution preview image. The "live view" mode will remain enabled after execution.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_preview_image_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_preview_image_finish ()

EntangleCameraFile * entangle_camera_preview_image_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_preview_image_async.

cam :

the camera. [transfer none]

Returns :

the captured image or NULL. [transfer full]

entangle_camera_download_file ()

gboolean            entangle_camera_download_file       (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GError **error);

Download the data associated with file and set the data on file.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

file :

the file whose contents to download. [transfer none]

Returns :

TRUE if the file was downloaded, FALSE on error

entangle_camera_download_file_async ()

void                entangle_camera_download_file_async (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Download the data associated with file and set the data on file.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_download_file_finish can be used to check the status

cam :

the camera. [transfer none]

file :

the file whose contents to download. [transfer none]

entangle_camera_download_file_finish ()

gboolean            entangle_camera_download_file_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **err);

Check the completion status of a previous call to entangle_camera_download_file_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the file was downloaded, FALSE on error

entangle_camera_delete_file ()

gboolean            entangle_camera_delete_file         (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GError **error);

Delete file from the camera capture target.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

file :

the file to delete. [transfer none]

Returns :

TRUE if the file was deleted, FALSE on error

entangle_camera_delete_file_async ()

void                entangle_camera_delete_file_async   (EntangleCamera *cam,
                                                         EntangleCameraFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Delete file from the camera capture target.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_delete_file_finish can be used to check the status

cam :

the camera. [transfer none]

file :

the file to delete. [transfer none]

entangle_camera_delete_file_finish ()

gboolean            entangle_camera_delete_file_finish  (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_delete_file_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the file was deleted, FALSE on error

entangle_camera_process_events ()

gboolean            entangle_camera_process_events      (EntangleCamera *cam,
                                                         guint64 waitms,
                                                         GError **error);

Wait upto waitms milliseconds for events to arrive from the camera. Signals will be emitted for any interesting events that arrive. Multiple events will be processed until waitms is exceeded.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

waitms :

the number of milliseconds to wait

Returns :

TRUE if the file was deleted, FALSE on error

entangle_camera_process_events_async ()

void                entangle_camera_process_events_async
                                                        (EntangleCamera *cam,
                                                         guint64 waitms,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Wait upto waitms milliseconds for events to arrive from the camera. Signals will be emitted for any interesting events that arrive. Multiple events will be processed until waitms is exceeded.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_process_events_finish can be used to check the status

cam :

the camera. [transfer none]

waitms :

the number of milliseconds to wait

entangle_camera_process_events_finish ()

gboolean            entangle_camera_process_events_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_process_events_async.

cam :

the camera. [transfer none]

Returns :

TRUE if events were processed, FALSE on error

entangle_camera_set_viewfinder ()

gboolean            entangle_camera_set_viewfinder      (EntangleCamera *cam,
                                                         gboolean enabled,
                                                         GError **error);

If enabled is TRUE, the view finder will be activated allowing preview images to be captured. If enabled is FALSE, the view finder will be deactivated.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

enabled :

TRUE to turn on the view finder

Returns :

TRUE if the viewer finder state was changed, FALSE on error

entangle_camera_set_viewfinder_async ()

void                entangle_camera_set_viewfinder_async
                                                        (EntangleCamera *cam,
                                                         gboolean enabled,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

If enabled is TRUE, the view finder will be activated allowing preview images to be captured. If enabled is FALSE, the view finder will be deactivated.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_set_viewfinder_finish can be used to check the status

cam :

the camera. [transfer none]

enabled :

TRUE to turn on the view finder

entangle_camera_set_viewfinder_finish ()

gboolean            entangle_camera_set_viewfinder_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_set_viewfinder_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the viewfinder state was changed, FALSE on error

entangle_camera_autofocus ()

gboolean            entangle_camera_autofocus           (EntangleCamera *cam,
                                                         GError **error);

Trigger the autofocus mechanism on the camera, waiting until focus is achieved or fails.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

TRUE if autofocus was achieved, FALSE on error

entangle_camera_autofocus_async ()

void                entangle_camera_autofocus_async     (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Trigger the autofocus mechanism on the camera, waiting until focus is achieved or fails.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_autofocus_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_autofocus_finish ()

gboolean            entangle_camera_autofocus_finish    (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_autofocus_async.

cam :

the camera. [transfer none]

Returns :

TRUE if autofocus was performed, FALSE on error

enum EntangleCameraManualFocusStep

typedef enum {
    ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_IN_COARSE,
    ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_IN_MEDIUM,
    ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_IN_FINE,
    ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_OUT_COARSE,
    ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_OUT_MEDIUM,
    ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_OUT_FINE,
} EntangleCameraManualFocusStep;

ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_IN_COARSE

ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_IN_MEDIUM

ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_IN_FINE

ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_OUT_COARSE

ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_OUT_MEDIUM

ENTANGLE_CAMERA_MANUAL_FOCUS_STEP_OUT_FINE


entangle_camera_manualfocus ()

gboolean            entangle_camera_manualfocus         (EntangleCamera *cam,
                                                         EntangleCameraManualFocusStep step,
                                                         GError **error);

Trigger the focus mechanism on the camera, to move by step.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

step :

how much to change focus by

Returns :

TRUE if autofocus was achieved, FALSE on error

entangle_camera_manualfocus_async ()

void                entangle_camera_manualfocus_async   (EntangleCamera *cam,
                                                         EntangleCameraManualFocusStep step,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Trigger the focus mechanism on the camera, to move by step.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_manualfocus_finish can be used to check the status

cam :

the camera. [transfer none]

step :

how much to change focus by

entangle_camera_manualfocus_finish ()

gboolean            entangle_camera_manualfocus_finish  (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_manualfocus_async.

cam :

the camera. [transfer none]

Returns :

TRUE if manual focus was performed, FALSE on error

entangle_camera_set_clock ()

gboolean            entangle_camera_set_clock           (EntangleCamera *cam,
                                                         gint64 epochsecs,
                                                         GError **error);

Update the camera clock to be epochsecs seconds since the epoch.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

epochsecs :

new time in seconds since the epoch

Returns :

TRUE if the clock was changed, FALSE on error

entangle_camera_set_clock_async ()

void                entangle_camera_set_clock_async     (EntangleCamera *cam,
                                                         gint64 epochsecs,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Update the camera clock to be epochsecs seconds since the epoch.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_set_clock_finish can be used to check the status

cam :

the camera. [transfer none]

epochsecs :

new time in seconds since the epoch

entangle_camera_set_clock_finish ()

gboolean            entangle_camera_set_clock_finish    (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_set_clock_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the clock was changed, FALSE on error

enum EntangleCameraCaptureTarget

typedef enum {
    ENTANGLE_CAMERA_CAPTURE_TARGET_RAM,
    ENTANGLE_CAMERA_CAPTURE_TARGET_CARD,
} EntangleCameraCaptureTarget;

ENTANGLE_CAMERA_CAPTURE_TARGET_RAM

ENTANGLE_CAMERA_CAPTURE_TARGET_CARD


entangle_camera_set_capture_target ()

gboolean            entangle_camera_set_capture_target  (EntangleCamera *cam,
                                                         EntangleCameraCaptureTarget target,
                                                         GError **error);

Set the destination for storing captured images to target.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

target :

the capture target

Returns :

TRUE if the capture target was changed, FALSE on error

entangle_camera_set_capture_target_async ()

void                entangle_camera_set_capture_target_async
                                                        (EntangleCamera *cam,
                                                         EntangleCameraCaptureTarget target,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Set the destination for storing captured images to target.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_set_clock_finish can be used to check the status

cam :

the camera. [transfer none]

target :

the capture target

entangle_camera_set_capture_target_finish ()

gboolean            entangle_camera_set_capture_target_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

entangle_camera_get_has_capture ()

gboolean            entangle_camera_get_has_capture     (EntangleCamera *cam);

Check if the camera supports images capture

cam :

the camera. [transfer none]

Returns :

TRUE if the camera supports image capture, FALSE otherwise

entangle_camera_get_has_preview ()

gboolean            entangle_camera_get_has_preview     (EntangleCamera *cam);

Check if the camera supports images preview

cam :

the camera. [transfer none]

Returns :

TRUE if the camera supports image preview, FALSE otherwise

entangle_camera_get_has_settings ()

gboolean            entangle_camera_get_has_settings    (EntangleCamera *cam);

Check if the camera supports configuration settings

cam :

the camera. [transfer none]

Returns :

TRUE if the camera supports configuration settings, FALSE otherwise

entangle_camera_get_has_viewfinder ()

gboolean            entangle_camera_get_has_viewfinder  (EntangleCamera *cam);

Check if the camera supports view finder control

cam :

the camera. [transfer none]

Returns :

TRUE if the camera supports view finder control, FALSE otherwise

entangle_camera_load_controls ()

gboolean            entangle_camera_load_controls       (EntangleCamera *cam,
                                                         GError **error);

Loads the configuration controls from the camera.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

TRUE if the controls were loaded, FALSE on error

entangle_camera_load_controls_async ()

void                entangle_camera_load_controls_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Loads the configuration controls from the camera.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_load_controls_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_load_controls_finish ()

gboolean            entangle_camera_load_controls_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_load_controls_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the controls were loaded, FALSE on error

entangle_camera_save_controls ()

gboolean            entangle_camera_save_controls       (EntangleCamera *cam,
                                                         GError **error);

Saves the configuration controls to the camera.

This can only be invoked when the camera is connected.

This block execution of the caller until completion.

cam :

the camera. [transfer none]

Returns :

TRUE if the controls were saved, FALSE on error

entangle_camera_save_controls_async ()

void                entangle_camera_save_controls_async (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Saves the configuration controls to the camera.

This can only be invoked when the camera is connected.

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_save_controls_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_save_controls_finish ()

gboolean            entangle_camera_save_controls_finish
                                                        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **error);

Check the completion status of a previous call to entangle_camera_save_controls_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the controls were saved, FALSE on error

entangle_camera_get_controls ()

EntangleControlGroup * entangle_camera_get_controls     (EntangleCamera *cam,
                                                         GError **error);

Get the configuration controls associated with the camera.

This can only be invoked when the camera is connected.

cam :

the camera. [transfer none]

Returns :

the controls, or NULL. [transfer full]

entangle_camera_set_progress ()

void                entangle_camera_set_progress        (EntangleCamera *cam,
                                                         EntangleProgress *prog);

Set the object instance to receive operation progress notifications

cam :

the camera. [transfer none]

prog :

the progress instance. [transfer none][allow-none]

entangle_camera_get_progress ()

EntangleProgress *  entangle_camera_get_progress        (EntangleCamera *cam);

Get the object instance that is receiving operation progress notifications

cam :

the camera. [transfer none]

Returns :

the progress object. [transfer full]

entangle_camera_is_mounted ()

gboolean            entangle_camera_is_mounted          (EntangleCamera *cam);

Check whether the camera is mounted as a virtual filesystem, which would prevent connecting it to.

cam :

the camera. [transfer none]

Returns :

TRUE if the camera is mounted, FALSE otherwise

entangle_camera_mount_async ()

void                entangle_camera_mount_async         (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

entangle_camera_mount_finish ()

gboolean            entangle_camera_mount_finish        (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **err);

entangle_camera_unmount_async ()

void                entangle_camera_unmount_async       (EntangleCamera *cam,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Unmount the camera virtual filesystem, allowing it to be connected to

This will execute in the background, and invoke callback when complete, whereupon entangle_camera_unmount_finish can be used to check the status

cam :

the camera. [transfer none]

entangle_camera_unmount_finish ()

gboolean            entangle_camera_unmount_finish      (EntangleCamera *cam,
                                                         GAsyncResult *result,
                                                         GError **err);

Check the completion status of a previous call to entangle_camera_unmount_async.

cam :

the camera. [transfer none]

Returns :

TRUE if the camera was unmounted, FALSE on error

Property Details

The "driver" property

  "driver"                   gchar*                : Read

Camera driver information.

Default value: NULL


The "has-capture" property

  "has-capture"              gboolean              : Read / Write / Construct Only

Whether image capture is supported.

Default value: FALSE


The "has-preview" property

  "has-preview"              gboolean              : Read / Write / Construct Only

Whether image preview is supported.

Default value: FALSE


The "has-settings" property

  "has-settings"             gboolean              : Read / Write / Construct Only

Whether camera settings configuration is supported.

Default value: FALSE


The "has-viewfinder" property

  "has-viewfinder"           gboolean              : Read / Write / Construct Only

Whether camera viewfinder configuration is supported.

Default value: FALSE


The "manual" property

  "manual"                   gchar*                : Read

Camera manual.

Default value: NULL


The "model" property

  "model"                    gchar*                : Read / Write / Construct Only

Model name of the camera.

Default value: NULL


The "port" property

  "port"                     gchar*                : Read / Write / Construct Only

Device port of the camera.

Default value: NULL


The "progress" property

  "progress"                 EntangleProgress*     : Read / Write

Operation progress updater.


The "summary" property

  "summary"                  gchar*                : Read

Camera summary.

Default value: NULL

Signal Details

The "camera-connected" signal

void                user_function                      (EntangleCamera *entanglecamera,
                                                        gpointer        user_data)           : Run First

The "camera-controls-changed" signal

void                user_function                      (EntangleCamera *entanglecamera,
                                                        gpointer        user_data)           : Run First

The "camera-disconnected" signal

void                user_function                      (EntangleCamera *entanglecamera,
                                                        gpointer        user_data)           : Run First

The "camera-file-added" signal

void                user_function                      (EntangleCamera     *entanglecamera,
                                                        EntangleCameraFile *arg1,
                                                        gpointer            user_data)           : Run First

The "camera-file-captured" signal

void                user_function                      (EntangleCamera     *entanglecamera,
                                                        EntangleCameraFile *arg1,
                                                        gpointer            user_data)           : Run First

The "camera-file-deleted" signal

void                user_function                      (EntangleCamera     *entanglecamera,
                                                        EntangleCameraFile *arg1,
                                                        gpointer            user_data)           : Run First

The "camera-file-downloaded" signal

void                user_function                      (EntangleCamera     *entanglecamera,
                                                        EntangleCameraFile *arg1,
                                                        gpointer            user_data)           : Run First

The "camera-file-previewed" signal

void                user_function                      (EntangleCamera     *entanglecamera,
                                                        EntangleCameraFile *arg1,
                                                        gpointer            user_data)           : Run First