← Back to branch summary

~noskcaj/ubuntu/trusty/entangle/merge

« back to all changes in this revision

Viewing changes to src/frontend/entangle-camera-manager.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2013-03-13 09:04:41 UTC
  • mfrom: (4.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130313090441-nmnggkwqumxzyh9s
Tags: 0.5.1-1
* New upstream release
* debian/rules: "gir" addon added to dh parameters

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/frontend/entangle-camera-manager.c
970
970
}
971
971
 
972
972
 
 
973
static void do_camera_set_viewfinder_finish(GObject *src,
 
974
                                            GAsyncResult *res,
 
975
                                            gpointer opaque)
 
976
{
 
977
    EntangleCameraFileTaskData *data = opaque;
 
978
    EntangleCamera *camera = ENTANGLE_CAMERA(src);
 
979
    GError *error = NULL;
 
980
 
 
981
    if (!entangle_camera_set_viewfinder_finish(camera, res, &error)) {
 
982
        do_camera_task_error(data->manager, _("Capture"), error);
 
983
        do_camera_task_complete(data);
 
984
        g_error_free(error);
 
985
        return;
 
986
    }
 
987
 
 
988
    do_camera_task_complete(data);
 
989
}
 
990
 
 
991
 
973
992
static void do_camera_preview_image_finish(GObject *src,
974
993
                                           GAsyncResult *res,
975
994
                                           gpointer opaque)
982
1001
 
983
1002
    if (!(file = entangle_camera_preview_image_finish(camera, res, &error))) {
984
1003
        if (g_cancellable_is_cancelled(priv->taskCancel) && priv->camera) {
 
1004
            if (entangle_camera_get_has_viewfinder(priv->camera))
 
1005
                entangle_camera_set_viewfinder_async(priv->camera,
 
1006
                                                     FALSE,
 
1007
                                                     NULL,
 
1008
                                                     do_camera_set_viewfinder_finish,
 
1009
                                                     data);
 
1010
            else
 
1011
                entangle_camera_capture_image_async(priv->camera,
 
1012
                                                    NULL,
 
1013
                                                    do_camera_capture_image_discard_finish,
 
1014
                                                    data);
 
1015
        } else {
 
1016
            priv->taskPreview = FALSE;
 
1017
            do_camera_task_error(data->manager, _("Preview"), error);
 
1018
            do_camera_task_complete(data);
 
1019
        }
 
1020
        g_error_free(error);
 
1021
        return;
 
1022
    }
 
1023
 
 
1024
    g_object_unref(file);
 
1025
 
 
1026
    if (g_cancellable_is_cancelled(priv->taskCancel)) {
 
1027
        if (entangle_camera_get_has_viewfinder(priv->camera))
 
1028
            entangle_camera_set_viewfinder_async(priv->camera,
 
1029
                                                 FALSE,
 
1030
                                                 NULL,
 
1031
                                                 do_camera_set_viewfinder_finish,
 
1032
                                                 data);
 
1033
        else
985
1034
            entangle_camera_capture_image_async(priv->camera,
986
1035
                                                NULL,
987
1036
                                                do_camera_capture_image_discard_finish,
988
1037
                                                data);
989
 
        } else {
990
 
            priv->taskPreview = FALSE;
991
 
            do_camera_task_error(data->manager, _("Preview"), error);
992
 
            do_camera_task_complete(data);
993
 
        }
994
 
        g_error_free(error);
995
 
        return;
996
 
    }
997
 
 
998
 
    g_object_unref(file);
999
 
 
1000
 
    if (g_cancellable_is_cancelled(priv->taskCancel)) {
1001
 
        entangle_camera_capture_image_async(priv->camera,
1002
 
                                            NULL,
1003
 
                                            do_camera_capture_image_discard_finish,
1004
 
                                            data);
1005
1038
    } else if (g_cancellable_is_cancelled(priv->taskConfirm)) {
1006
1039
        EntanglePreferences *prefs = entangle_application_get_preferences(priv->application);
1007
1040
 
1041
1074
        if (strncmp(entangle_camera_file_get_name(file),
1042
1075
                    priv->deleteImageDup,
1043
1076
                    len) == 0) {
1044
 
            fprintf(stderr, "Dup %s %s\n", priv->deleteImageDup, entangle_camera_file_get_name(file));
1045
1077
            g_free(priv->deleteImageDup);
1046
1078
            priv->deleteImageDup = NULL;
1047
1079
            entangle_camera_delete_file_async(camera,
1091
1123
}
1092
1124
 
1093
1125
 
1094
 
static void do_entangle_camera_progress_start(EntangleProgress *iface, float target, const char *format, va_list args)
 
1126
static void do_entangle_camera_progress_start(EntangleProgress *iface, float target, const char *msg)
1095
1127
{
1096
1128
    g_return_if_fail(ENTANGLE_IS_CAMERA_MANAGER(iface));
1097
1129
 
1098
1130
    EntangleCameraManager *manager = ENTANGLE_CAMERA_MANAGER(iface);
1099
1131
    EntangleCameraManagerPrivate *priv = manager->priv;
1100
1132
    GtkWidget *mtr;
1101
 
    char *txt;
1102
1133
    GtkWidget *operation;
1103
1134
 
1104
1135
    gdk_threads_enter();
1107
1138
    mtr = GTK_WIDGET(gtk_builder_get_object(priv->builder, "toolbar-progress"));
1108
1139
    operation = GTK_WIDGET(gtk_builder_get_object(priv->builder, "toolbar-operation"));
1109
1140
 
1110
 
    txt = g_strdup_vprintf(format, args);
1111
 
 
1112
 
    gtk_widget_set_tooltip_text(mtr, txt);
1113
 
    gtk_progress_bar_set_text(GTK_PROGRESS_BAR(mtr), txt);
 
1141
    gtk_widget_set_tooltip_text(mtr, msg);
 
1142
    gtk_progress_bar_set_text(GTK_PROGRESS_BAR(mtr), msg);
1114
1143
    gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(mtr), 0);
1115
1144
 
1116
1145
    gtk_widget_show(operation);
1117
1146
 
1118
 
    g_free(txt);
1119
 
 
1120
1147
    gdk_threads_leave();
1121
1148
}
1122
1149
 
2024
2051
}
2025
2052
 
2026
2053
 
 
2054
static void do_camera_autofocus_finish(GObject *source,
 
2055
                                       GAsyncResult *result,
 
2056
                                       gpointer data)
 
2057
{
 
2058
    g_return_if_fail(ENTANGLE_IS_CAMERA_MANAGER(data));
 
2059
 
 
2060
    EntangleCamera *camera = ENTANGLE_CAMERA(source);
 
2061
    GError *error = NULL;
 
2062
 
 
2063
    if (!entangle_camera_autofocus_finish(camera, result, &error)) {
 
2064
        gdk_threads_enter();
 
2065
        GtkWidget *msg = gtk_message_dialog_new(NULL,
 
2066
                                                0,
 
2067
                                                GTK_MESSAGE_ERROR,
 
2068
                                                GTK_BUTTONS_OK,
 
2069
                                                _("Autofocus failed"));
 
2070
        gtk_window_set_title(GTK_WINDOW(msg),
 
2071
                             _("Entangle: Camera autofocus failed"));
 
2072
        gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg),
 
2073
                                                 "%s",
 
2074
                                                 error->message);
 
2075
        g_signal_connect_swapped(msg,
 
2076
                                 "response",
 
2077
                                 G_CALLBACK (gtk_widget_destroy),
 
2078
                                 msg);
 
2079
        gtk_widget_show_all(msg);
 
2080
        gdk_threads_leave();
 
2081
 
 
2082
        g_error_free(error);
 
2083
    }
 
2084
}
 
2085
 
 
2086
 
 
2087
static void do_camera_manualfocus_finish(GObject *source,
 
2088
                                         GAsyncResult *result,
 
2089
                                         gpointer data)
 
2090
{
 
2091
    g_return_if_fail(ENTANGLE_IS_CAMERA_MANAGER(data));
 
2092
 
 
2093
    EntangleCamera *camera = ENTANGLE_CAMERA(source);
 
2094
    GError *error = NULL;
 
2095
 
 
2096
    if (!entangle_camera_manualfocus_finish(camera, result, &error)) {
 
2097
        gdk_threads_enter();
 
2098
        GtkWidget *msg = gtk_message_dialog_new(NULL,
 
2099
                                                0,
 
2100
                                                GTK_MESSAGE_ERROR,
 
2101
                                                GTK_BUTTONS_OK,
 
2102
                                                _("Manual focus failed"));
 
2103
        gtk_window_set_title(GTK_WINDOW(msg),
 
2104
                             _("Entangle: Camera manual focus failed"));
 
2105
        gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg),
 
2106
                                                 "%s",
 
2107
                                                 error->message);
 
2108
        g_signal_connect_swapped(msg,
 
2109
                                 "response",
 
2110
                                 G_CALLBACK (gtk_widget_destroy),
 
2111
                                 msg);
 
2112
        gtk_widget_show_all(msg);
 
2113
        gdk_threads_leave();
 
2114
 
 
2115
        g_error_free(error);
 
2116
    }
 
2117
}
 
2118
 
 
2119
 
2027
2120
gboolean do_manager_key_release(GtkWidget *widget G_GNUC_UNUSED,
2028
2121
                                GdkEventKey *ev,
2029
2122
                                gpointer data)
2059
2152
        entangle_preferences_img_set_mask_enabled(prefs, !enabled);
2060
2153
    }   break;
2061
2154
 
 
2155
    case GDK_KEY_a: {
 
2156
        if (priv->taskPreview) {
 
2157
            entangle_camera_autofocus_async(priv->camera,
 
2158
                                            NULL,
 
2159
                                            do_camera_autofocus_finish,
 
2160
                                            manager);
 
2161
        }
 
2162
    }
 
2163
 
 
2164
    case GDK_KEY_comma: {
 
2165
        if (priv->taskPreview) {
 
2166
            entangle_camera_manualfocus_async(priv->camera,
 
2167
                                              -1024,
 
2168
                                              NULL,
 
2169
                                              do_camera_manualfocus_finish,
 
2170
                                              manager);
 
2171
        }
 
2172
    }
 
2173
 
 
2174
    case GDK_KEY_period: {
 
2175
        if (priv->taskPreview) {
 
2176
            entangle_camera_manualfocus_async(priv->camera,
 
2177
                                              1024,
 
2178
                                              NULL,
 
2179
                                              do_camera_manualfocus_finish,
 
2180
                                              manager);
 
2181
        }
 
2182
    }
 
2183
 
2062
2184
    default:
2063
2185
        break;
2064
2186
    }