[vlc-devel] [RFC PATCH 2/5] dialog: rework API

Thomas Guillem thomas at gllm.fr
Thu Jan 28 19:11:57 CET 2016


This reworks the vlc dialog api:

 - dialog_Question is replaced by vlc_dialog_wait_question
 - dialog_Login is replaced by vlc_dialog_wait_login
 - dialog_Progress is replace by vlc_dialog_display_progress
 - dialog_Fatal is replaced by vlc_dialog_display_error
 - dialog_FatalWait is replaced by vlc_dialog_wait_question with i_type ==
   VLC_DIALOG_QUESTION_CRITICAL and without action1/action2

 - All dialogs (except vlc_dialog_display_error that returns immediatly) are
   interruptible via vlc_interrupt.

 - Nothing prevents to have more than one dialog type displayed at a time.
---
 include/vlc_dialog.h                              | 438 ++++++++---
 include/vlc_objects.h                             |   2 +
 modules/access/dvb/scan.c                         |  43 +-
 modules/access_output/file.c                      |  12 +-
 modules/codec/libass.c                            |  18 +-
 modules/demux/avi/avi.c                           |  48 +-
 modules/gui/qt4/dialogs/external.cpp              | 402 ++++++----
 modules/gui/qt4/dialogs/external.hpp              | 126 +++-
 modules/lua/extension.c                           |  57 +-
 modules/lua/extension.h                           |   2 +-
 modules/lua/extension_thread.c                    |   6 +-
 modules/misc/gnutls.c                             |  28 +-
 modules/misc/securetransport.c                    |  10 +-
 modules/text_renderer/freetype/fonts/fontconfig.c |  22 +-
 src/interface/dialog.c                            | 850 +++++++++++++++++-----
 src/libvlc.c                                      |  11 +
 src/libvlc.h                                      |   4 +-
 src/libvlccore.sym                                |  31 +-
 src/misc/keystore.c                               |  37 +-
 src/misc/update.c                                 |  58 +-
 test/modules/misc/tls.c                           |  34 +-
 21 files changed, 1606 insertions(+), 633 deletions(-)

diff --git a/include/vlc_dialog.h b/include/vlc_dialog.h
index 27eacd8..9c98640 100644
--- a/include/vlc_dialog.h
+++ b/include/vlc_dialog.h
@@ -18,119 +18,381 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
+/**
+ * @file
+ * This file declares VLC dialog API
+ */
+
 #ifndef VLC_DIALOG_H_
 #define VLC_DIALOG_H_
 # include <stdarg.h>
 
+typedef struct vlc_dialog_provider vlc_dialog_provider;
+typedef struct vlc_dialog_id vlc_dialog_id;
+
+
+/* Called from src/libvlc.c */
+vlc_dialog_provider *
+vlc_dialog_provider_new(void);
+
+/* Called from src/libvlc.c */
+void
+vlc_dialog_provider_release(vlc_dialog_provider *p_provider);
+
 /**
- * \ingroup interaction
+ * @defgroup vlc_dialog VLC dialog API
+ * @{
+ * @defgroup vlc_dialog_api API to interract with the user
  * @{
- * \file vlc_dialog.h
- * User interaction dialog APIs
  */
 
 /**
- * A fatal error dialog.
- * No response expected from the user.
+ * Dialog question type, see vlc_dialog_wait_question()
  */
-typedef struct dialog_fatal_t
+typedef enum vlc_dialog_question_type
 {
-    const char *title;
-    const char *message;
-} dialog_fatal_t;
+    VLC_DIALOG_QUESTION_NORMAL,
+    VLC_DIALOG_QUESTION_WARNING,
+    VLC_DIALOG_QUESTION_CRITICAL,
+} vlc_dialog_question_type;
 
-VLC_API void dialog_VFatal(vlc_object_t *, bool, const char *, const char *, va_list);
+/**
+ * Sends an error message
+ *
+ * This function returns immediately
+ *
+ * @param p_obj the VLC object emitting the error
+ * @param psz_title title of the error dialog
+ * @param psz_fmt format string for the error message
+ * @return VLC_SUCCESS on success, or a VLC error code on error
+ */
+VLC_API int
+vlc_dialog_display_error(vlc_object_t *p_obj, const char *psz_title,
+                         const char *psz_fmt, ...) VLC_FORMAT(3,4);
+#define vlc_dialog_display_error(a, b, c, ...) \
+    vlc_dialog_display_error(VLC_OBJECT(a), b, c, ##__VA_ARGS__)
 
-static inline VLC_FORMAT(3, 4)
-void dialog_Fatal (vlc_object_t *obj, const char *title, const char *fmt, ...)
-{
-     va_list ap;
+/**
+ * Sends an error message
+ *
+ * Equivalent to vlc_dialog_display_error() expect that it's called with a
+ * va_list.
+ */
+VLC_API int
+vlc_dialog_display_error_va(vlc_object_t *p_obj, const char *psz_title,
+                            const char *psz_fmt, va_list ap);
+/* TODO s/dialog_Fatal/vlc_dialog_display_error/g if accepted */
+#define dialog_Fatal vlc_dialog_display_error
 
-     va_start (ap, fmt);
-     dialog_VFatal(obj, false, title, fmt, ap);
-     va_end (ap);
-}
-#define dialog_Fatal(o, t, ...) \
-        dialog_Fatal(VLC_OBJECT(o), t, __VA_ARGS__)
+/**
+ * Requests an user name and a password
+ *
+ * This function waits until the user dismiss the dialog or responds (it's
+ * interruptible via vlc_interrupt).
+ * if p_store is not NULL, the user will be asked to store the password or not.
+ *
+ * @param p_obj the VLC object emitting the dialog
+ * @param ppsz_username a pointer to the user name provided by the user, it
+ * must be freed with free() on success
+ * @param ppsz_password a pointer to the password provided by the user, it must
+ * be freed with free() on success
+ * @param p_store a pointer to the store answer provided by the user (optional)
+ * @param psz_title title of the login dialog
+ * @param psz_fmt format string for the login message
+ * @return < 0 on error, 0 if the user cancelled it, and 1 if ppsz_username and
+ * ppsz_password are valid.
+ */
+VLC_API int
+vlc_dialog_wait_login(vlc_object_t *p_obj, char **ppsz_username,
+                      char **ppsz_password, bool *p_store,
+                      const char *psz_default_username,
+                      const char *psz_title, const char *psz_fmt, ...)
+                      VLC_FORMAT(7,8);
+#define vlc_dialog_wait_login(a, b, c, d, e, f, g, ...) \
+    vlc_dialog_wait_login(VLC_OBJECT(a), b, c, d, e, f, g, ##__VA_ARGS__)
 
-static inline VLC_FORMAT(3, 4)
-void dialog_FatalWait (vlc_object_t *obj, const char *title,
-                       const char *fmt, ...){
-     va_list ap;
+/**
+ * Requests an user name and a password
+ *
+ * Equivalent to vlc_dialog_wait_login() expect that it's called with a
+ * va_list.
+ */
+VLC_API int
+vlc_dialog_wait_login_va(vlc_object_t *p_obj, char **ppsz_username,
+                         char **ppsz_password, bool *p_store,
+                         const char *psz_default_username,
+                         const char *psz_title, const char *psz_fmt, va_list ap);
 
-     va_start (ap, fmt);
-     dialog_VFatal(obj, true, title, fmt, ap);
-     va_end (ap);
-}
-#define dialog_FatalWait(o, t, ...) \
-        dialog_FatalWait(VLC_OBJECT(o), t, __VA_ARGS__)
+/**
+ * Asks a total (Yes/No/Cancel) question
+ *
+ * This function waits until the user dismiss the dialog or responds (it's
+ * interruptible via vlc_interrupt).  The psz_cancel is mandatory since this
+ * dialog is always cancellable by the user.
+ *
+ * @param p_obj the VLC object emitting the dialog
+ * @param i_type question type (severity of the question)
+ * @param psz_cancel text of the cancel button
+ * @param psz_action1 first choice/button text (optional)
+ * @param psz_action2 second choice/button text (optional)
+ * @param psz_title title of the question dialog
+ * @param psz_fmt format string for the question message
+ * @return < 0 on error, 0 if the user cancelled it, 1 on action1, 2 on action2
+ */
+VLC_API int
+vlc_dialog_wait_question(vlc_object_t *p_obj,
+                         vlc_dialog_question_type i_type,
+                         const char *psz_cancel, const char *psz_action1,
+                         const char *psz_action2, const char *psz_title,
+                         const char *psz_fmt, ...) VLC_FORMAT(7,8);
+#define vlc_dialog_wait_question(a, b, c, d, e, f, g, ...) \
+    vlc_dialog_wait_question(VLC_OBJECT(a), b, c, d, e, f, g, ##__VA_ARGS__)
 
 /**
- * A login dialog.
+ * Asks a total (Yes/No/Cancel) question
+ *
+ * Equivalent to vlc_dialog_wait_question() expect that it's called with a
+ * va_list.
  */
-typedef struct dialog_login_t
-{
-    const char *title;
-    const char *message;
-    const char *default_username;
-    char **username;
-    char **password;
-    /* if store is NULL, password can't be stored (there is no keystore) */
-    bool *store;
-} dialog_login_t;
+VLC_API int
+vlc_dialog_wait_question_va(vlc_object_t *p_obj,
+                            vlc_dialog_question_type i_type,
+                            const char *psz_cancel, const char *psz_action1,
+                            const char *psz_action2, const char *psz_title,
+                            const char *psz_fmt, va_list ap);
+
+/**
+ * Display a progress dialog
+ *
+ * This function returns immediately
+ *
+ * @param p_obj the VLC object emitting the dialog
+ * @param b_indeterminate true if the progress dialog is indeterminate
+ * @param f_position initial position of the progress bar (between 0.0 and 1.0)
+ * @param psz_cancel text of the cancel button, if NULL the dialog is not
+ * cancellable (optional)
+ * @param psz_title title of the progress dialog
+ * @param psz_fmt format string for the progress message
+ * @return a valid vlc_dialog_id on success, must be released with
+ * vlc_dialog_id_release()
+ */
+VLC_API vlc_dialog_id *
+vlc_dialog_display_progress(vlc_object_t *p_obj, bool b_indeterminate,
+                            float f_position, const char *psz_cancel,
+                            const char *psz_title, const char *psz_fmt, ...)
+                            VLC_FORMAT(6,7);
+#define vlc_dialog_display_progress(a, b, c, d, e, f, ...) \
+    vlc_dialog_display_progress(VLC_OBJECT(a), b, c, d, e, f, ##__VA_ARGS__)
+
+/**
+ * Display a progress dialog
+ *
+ * Equivalent to vlc_dialog_display_progress() expect that it's called with a
+ * va_list.
+ */
+VLC_API vlc_dialog_id *
+vlc_dialog_display_progress_va(vlc_object_t *p_obj, bool b_indeterminate,
+                               float f_position, const char *psz_cancel,
+                               const char *psz_title, const char *psz_fmt,
+                               va_list ap);
+
+/**
+ * Update the position of the progress dialog
+ *
+ * @param f_position position of the progress bar (between 0.0 and 1.0)
+ * @return VLC_SUCCESS on success, or a VLC error code on error
+ */
+VLC_API int
+vlc_dialog_id_update_progress(vlc_dialog_id *p_id, float f_position);
+
+/**
+ * Update the position and the message of the progress dialog
+ *
+ * @param f_position position of the progress bar (between 0.0 and 1.0)
+ * @param psz_fmt format string for the progress message
+ * @return VLC_SUCCESS on success, or a VLC error code on error
+ */
+VLC_API int
+vlc_dialog_id_update_progress_text(vlc_dialog_id *p_id, float f_position,
+                                   const char *psz_fmt, ...);
 
-VLC_API void dialog_Login(vlc_object_t *, const char *, char **, char **, bool *, const char *, const char *, ...) VLC_FORMAT (7, 8);
-#define dialog_Login(o, u, p, s, t, v, w, ...) \
-        dialog_Login(VLC_OBJECT(o), u, p, s, t, v, w, __VA_ARGS__)
+/**
+ * Update the position and the message of the progress dialog
+ *
+ * Equivalent to vlc_dialog_id_update_progress_text() expect that it's called
+ * with a va_list.
+ */
+VLC_API int
+vlc_dialog_id_update_progress_text_va(vlc_dialog_id *p_id, float f_position,
+                                      const char *psz_fmt, va_list ap);
 
-VLC_API void dialog_vaLogin(vlc_object_t *, const char *, char **, char **, bool *, const char *, const char *, va_list args);
-#define dialog_vaLogin(o, u, p, s, t, v, w, x) \
-        dialog_vaLogin(VLC_OBJECT(o), u, p, s, t, v, w, x)
+/**
+ * Release the dialog id returned by vlc_dialog_display_progress()
+ */
+VLC_API void
+vlc_dialog_id_release(vlc_dialog_id *p_id);
 
+/**
+ * Release the dialog id returned by vlc_dialog_display_progress()
+ */
+VLC_API bool
+vlc_dialog_id_cancelled(vlc_dialog_id *p_id);
 
 /**
- * A question dialog.
+ * @}
+ * @defgroup vlc_dialog_implementation Implemented by GUI modules or libvlc
+ * @{
  */
-typedef struct dialog_question_t
+
+typedef enum vlc_dialog_type
+{
+    VLC_DIALOG_ERROR,
+    VLC_DIALOG_LOGIN,
+    VLC_DIALOG_QUESTION,
+    VLC_DIALOG_PROGRESS,
+} vlc_dialog_type;
+
+/** Dialog to be displayed */
+typedef struct vlc_dialog
+{
+    vlc_dialog_type i_type;
+    /** title of the dialog */
+    const char *psz_title;
+    /** text of the dialog */
+    const char *psz_text;
+
+    union
+    {
+        /** if i_type == VLC_DIALOG_LOGIN */
+        struct
+        {
+            /** default user name that should be set on the user form */
+            const char *psz_default_username;
+            /** if true, ask the user if he wants to save the credentials */
+            bool b_ask_store;
+        } login;
+        /** if i_type == VLC_DIALOG_QUESTION */
+        struct
+        {
+            /** question type (or severity) of the dialog */
+            vlc_dialog_question_type i_type;
+            /** text of the cancel button */
+            const char *psz_cancel;
+            /** text of the first button (optional) */
+            const char *psz_action1;
+            /** text of the second button (optional) */
+            const char *psz_action2;
+        } question;
+        /** if i_type == VLC_DIALOG_PROGRESS */
+        struct
+        {
+            /** true if the progress dialog is indeterminate */
+            bool b_indeterminate;
+            /** initial position of the progress bar (between 0.0 and 1.0) */
+            float f_position;
+            /** text of the cancel button, if NULL the dialog is not
+             * cancellable (optional) */
+            const char *psz_cancel;
+        } progress;
+    } u;
+} vlc_dialog;
+
+/** Dialog callbacks to be implemented */
+typedef struct vlc_dialog_cbs
 {
-    const char *title;
-    const char *message;
-    const char *yes;
-    const char *no;
-    const char *cancel;
-    int answer;
-} dialog_question_t;
-
-VLC_API int dialog_Question(vlc_object_t *, const char *, const char *,
-                            const char *, const char *, const char *, ...)
-VLC_FORMAT(3, 7);
-#define dialog_Question(o, t, m, y, n, ...) \
-        dialog_Question(VLC_OBJECT(o), t, m, y, n, __VA_ARGS__)
-
-typedef struct dialog_progress_bar_t
-{   /* Request-time parameters */
-    const char *title;
-    const char *message;
-    const char *cancel;
-    /* Permanent parameters */
-    void (*pf_update) (void *, const char *, float);
-    bool (*pf_check) (void *);
-    void (*pf_destroy) (void *);
-    void *p_sys;
-} dialog_progress_bar_t;
-
-VLC_API dialog_progress_bar_t * dialog_ProgressCreate(vlc_object_t *, const char *, const char *, const char *) VLC_USED;
-#define dialog_ProgressCreate(o, t, m, c) \
-        dialog_ProgressCreate(VLC_OBJECT(o), t, m, c)
-VLC_API void dialog_ProgressDestroy(dialog_progress_bar_t *);
-VLC_API void dialog_ProgressSet(dialog_progress_bar_t *, const char *, float);
-VLC_API bool dialog_ProgressCancelled(dialog_progress_bar_t *);
-
-VLC_API int dialog_Register(vlc_object_t *);
-VLC_API int dialog_Unregister(vlc_object_t *);
-#define dialog_Register(o) dialog_Register(VLC_OBJECT(o))
-#define dialog_Unregister(o) dialog_Unregister(VLC_OBJECT(o))
-
-/** @} */
+    /**
+     * Called when a new dialog need to be displayed
+     *
+     * @param p_id id used to interact with the dialog, valid until pf_cancel
+     * is called, can be null (for the VLC_DIALOG_ERROR case)
+     * @param p_dialog all informations that need to be displayed
+     * @param p_data opaque pointer for the callback
+     * @return true if the dialog is handled by the callback, false otherwise
+     */
+    bool (*pf_display)(vlc_dialog_id *p_id, vlc_dialog *p_dialog, void *p_data);
+    /**
+     * Called when a displayed dialog need to be cancelled
+     *
+     * @param p_id id of the dialog
+     * @param p_data opaque pointer for the callback
+     * @return true, then p_id will be released and won't be usable after.
+     * False, implementation must release the dialog with vlc_dialog_id_dismiss
+     */
+    bool (*pf_cancel)(vlc_dialog_id *p_id, void *p_data);
+    /**
+     * Called when a progress dialog need to be updated
+     *
+     * @param p_id id of the dialog
+     * @param f_position osition of the progress bar (between 0.0 and 1.0)
+     * @param psz_text new text of the progress dialog
+     * @param p_data opaque pointer for the callback
+     */
+    void (*pf_update_progress)(vlc_dialog_id *p_id, float f_position,
+                               const char *psz_text, void *p_data);
+} vlc_dialog_cbs;
+
+/**
+ * Register callbacks for the VLC dialog
+ *
+ * @param p_cbs a pointer to callbacks, or NULL to unregister callbacks.
+ * @param p_data opaque pointer for the callback
+ */
+VLC_API void
+vlc_dialog_provider_set_callbacks(vlc_object_t *p_obj,
+                                  vlc_dialog_cbs *p_cbs, void *p_data);
+#define vlc_dialog_provider_set_callbacks(a, b, c) \
+    vlc_dialog_provider_set_callbacks(VLC_OBJECT(a), b, c)
+
+/**
+ * Associate an opaque pointer with the dialog id
+ */
+VLC_API void
+vlc_dialog_id_set_context(vlc_dialog_id *p_id, void *p_context);
+
+/**
+ * Return the opaque pointer associated with the dialog id
+ */
+VLC_API void *
+vlc_dialog_id_get_context(vlc_dialog_id *p_id);
+
+/**
+ * Post a login answer
+ *
+ * After this call, p_id won't be valid anymore
+ *
+ * @param p_id id of the dialog
+ * @param psz_username valid and non empty string
+ * @param psz_password valid string (can be empty)
+ * @param b_store if true, store the credentials
+ * @return VLC_SUCCESS on success, or a VLC error code on error
+ */
+VLC_API int
+vlc_dialog_id_post_login(vlc_dialog_id *p_id, const char *psz_username,
+                         const char *psz_password, bool b_store);
+
+/**
+ * Post a question answer
+ *
+ * After this call, p_id won't be valid anymore
+ *
+ * @param p_id id of the dialog
+ * @param i_action 1 or action1, 2 for action2
+ * @return VLC_SUCCESS on success, or a VLC error code on error
+ */
+VLC_API int
+vlc_dialog_id_post_action(vlc_dialog_id *p_id, int i_action);
+
+/**
+ * Dismiss a dialog
+ *
+ * After this call, p_id won't be valid anymore
+ *
+ * @param p_id id of the dialog
+ * @return VLC_SUCCESS on success, or a VLC error code on error
+ */
+VLC_API int
+vlc_dialog_id_dismiss(vlc_dialog_id *p_id);
+
+/** @} @} */
 
 #endif
diff --git a/include/vlc_objects.h b/include/vlc_objects.h
index 598313e..12f754a 100644
--- a/include/vlc_objects.h
+++ b/include/vlc_objects.h
@@ -41,6 +41,8 @@ struct vlc_object_t
     VLC_COMMON_MEMBERS
 };
 
+typedef struct vlc_dialog_provider vlc_dialog_provider;
+
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
diff --git a/modules/access/dvb/scan.c b/modules/access/dvb/scan.c
index f12d015..e8f001c 100644
--- a/modules/access/dvb/scan.c
+++ b/modules/access/dvb/scan.c
@@ -87,7 +87,7 @@ typedef struct
 struct scan_t
 {
     vlc_object_t *p_obj;
-    struct dialog_progress_bar_t *p_dialog;
+    vlc_dialog_id *p_dialog_id;
     uint64_t i_index;
     scan_parameter_t parameter;
     int64_t i_time_start;
@@ -212,7 +212,7 @@ scan_t *scan_New( vlc_object_t *p_obj, const scan_parameter_t *p_parameter )
 
     p_scan->p_obj = VLC_OBJECT(p_obj);
     p_scan->i_index = 0;
-    p_scan->p_dialog = NULL;
+    p_scan->p_dialog_id = NULL;
     TAB_INIT( p_scan->i_service, p_scan->pp_service );
     p_scan->parameter = *p_parameter;
     p_scan->i_time_start = mdate();
@@ -222,8 +222,8 @@ scan_t *scan_New( vlc_object_t *p_obj, const scan_parameter_t *p_parameter )
 
 void scan_Destroy( scan_t *p_scan )
 {
-    if( p_scan->p_dialog != NULL )
-        dialog_ProgressDestroy( p_scan->p_dialog );
+    if( p_scan->p_dialog_id != NULL )
+        vlc_dialog_id_release( p_scan->p_dialog_id );
 
     for( int i = 0; i < p_scan->i_service; i++ )
         scan_service_Delete( p_scan->pp_service[i] );
@@ -647,7 +647,6 @@ int scan_Next( scan_t *p_scan, scan_configuration_t *p_cfg )
     if( i_ret )
         return i_ret;
 
-    char *psz_text;
     int i_service = 0;
 
     for( int i = 0; i < p_scan->i_service; i++ )
@@ -658,18 +657,28 @@ int scan_Next( scan_t *p_scan, scan_configuration_t *p_cfg )
 
     const mtime_t i_eta = f_position > 0.005 ? (mdate() - p_scan->i_time_start) * ( 1.0 / f_position - 1.0 ) : -1;
     char psz_eta[MSTRTIME_MAX_SIZE];
+    const char *psz_fmt = _("%.1f MHz (%d services)\n~%s remaining");
 
-    if( asprintf( &psz_text, _("%.1f MHz (%d services)\n~%s remaining"),
-                  (double)p_cfg->i_frequency / 1000000, i_service, secstotimestr( psz_eta, i_eta/1000000 ) ) >= 0 )
+    if( i_eta >= 0 )
+        msg_Info( p_scan->p_obj, "Scan ETA %s | %f", secstotimestr( psz_eta, i_eta/1000000 ), f_position * 100 );
+
+    if( p_scan->p_dialog_id == NULL )
     {
-        if( i_eta >= 0 )
-            msg_Info( p_scan->p_obj, "Scan ETA %s | %f", secstotimestr( psz_eta, i_eta/1000000 ), f_position * 100 );
-
-        if( p_scan->p_dialog == NULL )
-            p_scan->p_dialog = dialog_ProgressCreate( p_scan->p_obj, _("Scanning DVB"), psz_text, _("Cancel") );
-        if( p_scan->p_dialog != NULL )
-            dialog_ProgressSet( p_scan->p_dialog, psz_text, f_position );
-        free( psz_text );
+        p_scan->p_dialog_id =
+            vlc_dialog_display_progress( p_scan->p_obj, false,
+                                         f_position, _("Cancel"),
+                                         _("Scanning DVB"), psz_fmt,
+                                         (double)p_cfg->i_frequency / 1000000,
+                                         i_service,
+                                         secstotimestr( psz_eta, i_eta/1000000 ) );
+    }
+    else
+    {
+        vlc_dialog_id_update_progress_text( p_scan->p_dialog_id,
+                                            f_position, psz_fmt,
+                                            (double)p_cfg->i_frequency / 1000000,
+                                            i_service,
+                                            secstotimestr( psz_eta, i_eta/1000000 ) );
     }
 
     p_scan->i_index++;
@@ -678,7 +687,9 @@ int scan_Next( scan_t *p_scan, scan_configuration_t *p_cfg )
 
 bool scan_IsCancelled( scan_t *p_scan )
 {
-    return p_scan->p_dialog && dialog_ProgressCancelled( p_scan->p_dialog );
+    if( p_scan->p_dialog_id == NULL )
+        return false;
+    return vlc_dialog_id_cancelled( p_scan->p_dialog_id );
 }
 
 static scan_service_t *ScanFindService( scan_t *p_scan, int i_service_start, int i_program )
diff --git a/modules/access_output/file.c b/modules/access_output/file.c
index 2e61e32..34a0329 100644
--- a/modules/access_output/file.c
+++ b/modules/access_output/file.c
@@ -318,12 +318,12 @@ static int Open( vlc_object_t *p_this )
                 break;
             flags &= ~O_EXCL;
         }
-        while (dialog_Question (p_access, path,
-                                _("The output file already exists. "
-                                "If recording continues, the file will be "
-                                "overridden and its content will be lost."),
-                                _("Keep existing file"),
-                                _("Overwrite"), NULL) == 2);
+        while (vlc_dialog_wait_question (p_access, VLC_DIALOG_QUESTION_NORMAL,
+                                         _("Keep existing file"),
+                                         _("Overwrite"), NULL, path,
+                                         _("The output file already exists. "
+                                         "If recording continues, the file will be "
+                                         "overridden and its content will be lost.")) == 1);
         free (buf);
         if (fd == -1)
             return VLC_EGENERIC;
diff --git a/modules/codec/libass.c b/modules/codec/libass.c
index 77240e7..920148a 100644
--- a/modules/codec/libass.c
+++ b/modules/codec/libass.c
@@ -225,19 +225,17 @@ static int Create( vlc_object_t *p_this )
 
 #ifdef HAVE_FONTCONFIG
 #if defined(_WIN32)
-    dialog_progress_bar_t *p_dialog =
-        dialog_ProgressCreate( p_dec,
-                               _("Building font cache"),
-                               _( "Please wait while your font cache is rebuilt.\n"
-                                  "This should take less than a minute." ), NULL );
+    int i_ret =
+        vlc_dialog_display_progress( p_dec, true, 0.0, NULL,
+                                    _("Building font cache"),
+                                    _( "Please wait while your font cache is rebuilt.\n"
+                                    "This should take less than a minute." ) );
+    unsigned int i_dialog_id = i_ret > 0 ? i_ret : 0;
 #endif
     ass_set_fonts( p_renderer, psz_font, psz_family, 1, NULL, 1 );  // setup default font/family
 #if defined(_WIN32)
-    if( p_dialog )
-    {
-        dialog_ProgressSet( p_dialog, NULL, 1.0 );
-        dialog_ProgressDestroy( p_dialog );
-    }
+    if( i_dialog_id != 0 )
+        vlc_dialog_cancel( p_dec, i_dialog_id );
 #endif
 #else
     ass_set_fonts( p_renderer, psz_font, psz_family, 1, NULL, 1 );
diff --git a/modules/demux/avi/avi.c b/modules/demux/avi/avi.c
index 425748a..8e1b34e 100644
--- a/modules/demux/avi/avi.c
+++ b/modules/demux/avi/avi.c
@@ -753,22 +753,28 @@ aviindex:
             }
             if( i_do_index == 0 )
             {
-                switch( dialog_Question( p_demux, _("Broken or missing AVI Index") ,
-                   _( "Because this AVI file index is broken or missing, "
-                      "seeking will not work correctly.\n"
-                      "VLC won't repair your file but can temporary fix this "
-                      "problem by building an index in memory.\n"
-                      "This step might take a long time on a large file.\n"
-                      "What do you want to do?" ),
-                      _( "Build index then play" ), _( "Play as is" ), _( "Do not play") ) )
+                const char *psz_msg = _(
+                    "Because this AVI file index is broken or missing, "
+                    "seeking will not work correctly.\n"
+                    "VLC won't repair your file but can temporary fix this "
+                    "problem by building an index in memory.\n"
+                    "This step might take a long time on a large file.\n"
+                    "What do you want to do?");
+                switch( vlc_dialog_wait_question( p_demux,
+                                                  VLC_DIALOG_QUESTION_NORMAL,
+                                                  _("Do not play"),
+                                                  _("Build index then play"),
+                                                  _("Play as is"),
+                                                  _("Broken or missing AVI Index"),
+                                                  "%s", psz_msg ) )
                 {
+                    case 0:
+                        b_aborted = true;
+                        goto error;
                     case 1:
                         b_index = true;
                         msg_Dbg( p_demux, "Fixing AVI index" );
                         goto aviindex;
-                    case 3:
-                        b_aborted = true;
-                        goto error;
                 }
             }
             else
@@ -2609,7 +2615,7 @@ static void AVI_IndexCreate( demux_t *p_demux )
     off_t i_movi_end;
 
     mtime_t i_dialog_update;
-    dialog_progress_bar_t *p_dialog = NULL;
+    vlc_dialog_id *p_dialog_id = NULL;
 
     p_riff = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, 0);
     p_movi = AVI_ChunkFind( p_riff, AVIFOURCC_movi, 0);
@@ -2633,23 +2639,27 @@ static void AVI_IndexCreate( demux_t *p_demux )
     /* Only show dialog if AVI is > 10MB */
     i_dialog_update = mdate();
     if( stream_Size( p_demux->s ) > 10000000 )
-        p_dialog = dialog_ProgressCreate( p_demux, _("Fixing AVI Index..."),
-                                       NULL, _("Cancel") );
+    {
+        p_dialog_id =
+            vlc_dialog_display_progress( p_demux, false, 0.0, _("Cancel"),
+                                         _("Broken or missing AVI Index"),
+                                         _("Fixing AVI Index...") );
+    }
 
     for( ;; )
     {
         avi_packet_t pk;
 
         /* Don't update/check dialog too often */
-        if( p_dialog && mdate() - i_dialog_update > 100000 )
+        if( p_dialog_id != NULL && mdate() - i_dialog_update > 100000 )
         {
-            if( dialog_ProgressCancelled( p_dialog ) )
+            if( vlc_dialog_id_cancelled( p_dialog_id ) )
                 break;
 
             double f_current = stream_Tell( p_demux->s );
             double f_size    = stream_Size( p_demux->s );
             double f_pos     = f_current / f_size;
-            dialog_ProgressSet( p_dialog, NULL, f_pos );
+            vlc_dialog_id_update_progress( p_dialog_id, f_pos );
 
             i_dialog_update = mdate();
         }
@@ -2714,8 +2724,8 @@ static void AVI_IndexCreate( demux_t *p_demux )
     }
 
 print_stat:
-    if( p_dialog != NULL )
-        dialog_ProgressDestroy( p_dialog );
+    if( p_dialog_id != NULL )
+        vlc_dialog_id_release( p_dialog_id );
 
     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
     {
diff --git a/modules/gui/qt4/dialogs/external.cpp b/modules/gui/qt4/dialogs/external.cpp
index 9c7ebfd..a23dc92 100644
--- a/modules/gui/qt4/dialogs/external.cpp
+++ b/modules/gui/qt4/dialogs/external.cpp
@@ -23,96 +23,172 @@
 # include <config.h>
 #endif
 
-//#include "qt4.hpp"
 #include "external.hpp"
 #include "errors.hpp"
-#include <vlc_dialog.h>
 
-#include <QDialog>
+#include <assert.h>
+
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMessageBox>
 #include <QProgressDialog>
-#include <QMutex>
 #include <QPushButton>
-#include <QTimer>
 
 DialogHandler::DialogHandler (intf_thread_t *p_intf, QObject *_parent)
-    : QObject( _parent ), p_intf (p_intf),
-      critical (VLC_OBJECT(p_intf), "dialog-critical"),
-      login (VLC_OBJECT(p_intf), "dialog-login"),
-      question (VLC_OBJECT(p_intf), "dialog-question"),
-      progressBar (VLC_OBJECT(p_intf), "dialog-progress-bar")
+    : QObject( _parent ), p_intf (p_intf)
+{
+    vlc_dialog_cbs cbs = {
+        displayCb,
+        cancelCb,
+        updateProgressCb
+    };
+    vlc_dialog_provider_set_callbacks(p_intf, &cbs, this);
+
+    CONNECT(this, errorDisplayed(const QString &, const QString &),
+            this, displayError(const QString &, const QString &));
+
+    CONNECT(this, loginDisplayed(vlc_dialog_id *, const QString &,
+                                 const QString &, const QString &, bool),
+            this, displayLogin(vlc_dialog_id *, const QString &, const QString &,
+                               const QString &, bool));
+
+    CONNECT(this, questionDisplayed(vlc_dialog_id *, const QString &,
+                                    const QString &, int, const QString &,
+                                    const QString &, const QString &),
+            this, displayQuestion(vlc_dialog_id *, const QString &, const QString &,
+                                  int, const QString &, const QString &,
+                                  const QString &));
+
+    CONNECT(this, progressDisplayed(vlc_dialog_id *, const QString &, const QString &,
+                                    bool, float, const QString &),
+            this, displayProgress(vlc_dialog_id *, const QString &, const QString &,
+                                  bool, float, const QString &));
+
+    CONNECT(this, cancelled(vlc_dialog_id *), this, cancel(vlc_dialog_id *));
+
+    CONNECT(this, progressUpdated(vlc_dialog_id *, float, const QString &),
+            this, updateProgress(vlc_dialog_id *, float, const QString &));
+}
+
+DialogHandler::~DialogHandler()
 {
-    var_Create (p_intf, "dialog-error", VLC_VAR_ADDRESS);
-    var_AddCallback (p_intf, "dialog-error", error, this);
-    connect (this, SIGNAL(error(const QString &, const QString &)),
-             SLOT(displayError(const QString &, const QString &)));
-
-    critical.addCallback(this, SLOT(displayCritical(void *)),
-                         Qt::BlockingQueuedConnection);
-    login.addCallback(this, SLOT(requestLogin(void *)),
-                      Qt::BlockingQueuedConnection);
-    question.addCallback(this, SLOT(requestAnswer(void *)),
-                         Qt::BlockingQueuedConnection);
-    progressBar.addCallback(this, SLOT(startProgressBar(void *)),
-                            Qt::BlockingQueuedConnection);
-
-    dialog_Register (p_intf);
+    vlc_dialog_provider_set_callbacks(p_intf, NULL, NULL);
 }
 
-DialogHandler::~DialogHandler (void)
+bool DialogHandler::displayCb(vlc_dialog_id *p_id, vlc_dialog *p_dialog,
+                              void *p_data)
 {
-    dialog_Unregister (p_intf);
+    DialogHandler *self =  static_cast<DialogHandler *>(p_data);
+    const QString title = qfu(p_dialog->psz_title);
+    const QString text = qfu(p_dialog->psz_text);
 
-    var_DelCallback (p_intf, "dialog-error", error, this);
-    var_Destroy (p_intf, "dialog-error");
+    switch (p_dialog->i_type)
+    {
+        case VLC_DIALOG_ERROR:
+            emit self->errorDisplayed(title, text);
+            break;
+        case VLC_DIALOG_LOGIN:
+        {
+            assert(p_id != NULL);
+            const QString defaultUsername =
+                p_dialog->u.login.psz_default_username != NULL ?
+                qfu(p_dialog->u.login.psz_default_username) : QString();
+
+            emit self->loginDisplayed(p_id, title, text, defaultUsername,
+                                      p_dialog->u.login.b_ask_store);
+            break;
+        }
+        case VLC_DIALOG_QUESTION:
+        {
+            assert(p_id != NULL);
+            const QString cancel = qfu(p_dialog->u.question.psz_cancel);
+            const QString action1 = p_dialog->u.question.psz_action1 != NULL ?
+                qfu(p_dialog->u.question.psz_action1) : QString();
+            const QString action2 = p_dialog->u.question.psz_action2 != NULL ?
+                qfu(p_dialog->u.question.psz_action2) : QString();
+
+            emit self->questionDisplayed(p_id, title, text,
+                                         p_dialog->u.question.i_type,
+                                         cancel, action1, action2);
+            break;
+        }
+        case VLC_DIALOG_PROGRESS:
+        {
+            assert(p_id != NULL);
+            const QString cancel = p_dialog->u.progress.psz_cancel != NULL ?
+                qfu(p_dialog->u.progress.psz_cancel) : QString();
+            emit self->progressDisplayed(p_id, title, text,
+                                         p_dialog->u.progress.b_indeterminate,
+                                         p_dialog->u.progress.f_position, cancel);
+            break;
+        }
+    }
+    return true;
 }
 
-int DialogHandler::error (vlc_object_t *obj, const char *,
-                          vlc_value_t, vlc_value_t value, void *data)
+bool DialogHandler::cancelCb(vlc_dialog_id *p_id, void *p_data)
 {
-    const dialog_fatal_t *dialog = (const dialog_fatal_t *)value.p_address;
-    DialogHandler *self = static_cast<DialogHandler *>(data);
+    DialogHandler *self = static_cast<DialogHandler *>(p_data);
+    emit self->cancelled(p_id);
+    return false;
+}
 
-    if (var_InheritBool (obj, "qt-error-dialogs"))
-        emit self->error (qfu(dialog->title), qfu(dialog->message));
-    return VLC_SUCCESS;
+void DialogHandler::updateProgressCb(vlc_dialog_id *p_id, float f_value,
+                                     const char *psz_text, void *p_data)
+{
+    DialogHandler *self = static_cast<DialogHandler *>(p_data);
+    emit self->progressUpdated(p_id, f_value, qfu(psz_text));
 }
 
-void DialogHandler::displayError (const QString& title, const QString& message)
+void DialogHandler::cancel(vlc_dialog_id *p_id)
 {
-    ErrorsDialog::getInstance (p_intf)->addError(title, message);
+    DialogWrapper *p_wrapper =
+        static_cast<DialogWrapper *>(vlc_dialog_id_get_context(p_id));
+    if (p_wrapper != NULL)
+        p_wrapper->finish(QDialog::Rejected);
 }
 
-void DialogHandler::displayCritical (void *value)
+void DialogHandler::updateProgress(vlc_dialog_id *p_id, float f_value,
+                                   const QString &text)
 {
-    const dialog_fatal_t *dialog = (const dialog_fatal_t *)value;
+    DialogWrapper *p_wrapper =
+        static_cast<DialogWrapper *>(vlc_dialog_id_get_context(p_id));
 
-    QMessageBox::critical (NULL, qfu(dialog->title), qfu(dialog->message),
-                           QMessageBox::Ok);
+    ProgressDialogWrapper *p_progress_wrapper
+        = dynamic_cast<ProgressDialogWrapper *>(p_wrapper);
+
+    if (p_progress_wrapper != NULL)
+        p_progress_wrapper->updateProgress(f_value, text);
 }
 
-void DialogHandler::requestLogin (void *value)
+void DialogHandler::displayError(const QString &title, const QString &text)
 {
-    dialog_login_t *data = (dialog_login_t *)value;
-    QDialog *dialog = new QDialog;
+    ErrorsDialog::getInstance (p_intf)->addError(title, text);
+}
+
+void DialogHandler::displayLogin(vlc_dialog_id *p_id, const QString &title,
+                                 const QString &text,
+                                 const QString &defaultUsername,
+                                 bool b_ask_store)
+{
+    QDialog *dialog = new QDialog();
     QLayout *layout = new QVBoxLayout (dialog);
 
-    dialog->setWindowTitle (qfu(data->title));
+    dialog->setWindowTitle (title);
     dialog->setWindowRole ("vlc-login");
+    dialog->setModal(true);
     layout->setMargin (2);
 
     /* Username and password fields */
     QWidget *panel = new QWidget (dialog);
     QGridLayout *grid = new QGridLayout;
-    grid->addWidget (new QLabel (qfu(data->message)), 0, 0, 1, 2);
+    grid->addWidget (new QLabel (text), 0, 0, 1, 2);
 
     QLineEdit *userLine = new QLineEdit;
-    if (data->default_username != NULL)
-        userLine->setText(qtr(data->default_username));
+    if (!defaultUsername.isEmpty())
+        userLine->setText(defaultUsername);
     grid->addWidget (new QLabel (qtr("Username")), 1, 0);
     grid->addWidget (userLine, 1, 1);
 
@@ -122,7 +198,7 @@ void DialogHandler::requestLogin (void *value)
     grid->addWidget (passLine, 2, 1);
 
     QCheckBox *checkbox = NULL;
-    if (data->store != NULL)
+    if (b_ask_store)
     {
         checkbox = new QCheckBox;
         checkbox->setChecked (getSettings()->value ("store_password", true).toBool ());
@@ -134,7 +210,7 @@ void DialogHandler::requestLogin (void *value)
     layout->addWidget (panel);
 
     /* focus on passLine if the username is already set */
-    if (data->default_username != NULL)
+    if (!defaultUsername.isEmpty())
         passLine->setFocus();
 
     /* OK, Cancel buttons */
@@ -148,126 +224,172 @@ void DialogHandler::requestLogin (void *value)
     CONNECT( buttonBox, rejected(), dialog, reject() );
     layout->addWidget (buttonBox);
 
-    /* Run the dialog */
     dialog->setLayout (layout);
+    vlc_dialog_id_set_context(p_id,
+        new LoginDialogWrapper(this, p_intf, p_id, dialog, userLine, passLine,
+                               checkbox));
+    dialog->show();
+}
 
-    if (dialog->exec ())
+void
+DialogHandler::displayQuestion(vlc_dialog_id *p_id, const QString &title,
+                               const QString &text, int i_type,
+                               const QString &cancel, const QString &action1,
+                               const QString &action2)
+{
+    enum QMessageBox::Icon icon;
+    switch (i_type)
     {
-        *data->username = strdup (qtu(userLine->text ()));
-        *data->password = strdup (qtu(passLine->text ()));
-        if (data->store != NULL)
-        {
-            *data->store = checkbox->isChecked ();
-            getSettings()->setValue ("store_password", *data->store);
-        }
+        case VLC_DIALOG_QUESTION_WARNING:
+            icon = QMessageBox::Warning;
+            break;
+        case VLC_DIALOG_QUESTION_CRITICAL:
+            icon = QMessageBox::Critical;
+            break;
+        default:
+        case VLC_DIALOG_QUESTION_NORMAL:
+            icon = action1.isEmpty() && action2.isEmpty() ?
+                 QMessageBox::Information : QMessageBox::Question;
+            break;
     }
+    QMessageBox *box = new QMessageBox (icon, title, text);
+    box->addButton ("&" + cancel, QMessageBox::RejectRole);
+    box->setModal(true);
+    QAbstractButton *action1Button = NULL;
+    if (!action1.isEmpty())
+        action1Button = box->addButton("&" + action1, QMessageBox::AcceptRole);
+    QAbstractButton *action2Button = NULL;
+    if (!action2.isEmpty())
+        action2Button = box->addButton("&" + action2, QMessageBox::AcceptRole);
+
+    vlc_dialog_id_set_context(p_id,
+        new QuestionDialogWrapper(this, p_intf, p_id, box, action1Button,
+                                  action2Button));
+    box->show();
+}
+
+void DialogHandler::displayProgress(vlc_dialog_id *p_id, const QString &title,
+                                    const QString &text, bool b_indeterminate,
+                                    float f_position, const QString &cancel)
+{
+    QProgressDialog *progress =
+        new QProgressDialog(text, cancel.isEmpty() ? QString() : "&" + cancel,
+                            0, b_indeterminate ? 0 : 1000);
+    progress->setWindowTitle(title);
+    if (!cancel.isEmpty())
+        progress->setModal(true);
     else
     {
-        *data->username = *data->password = NULL;
-        if (data->store != NULL)
-            *data->store = false;
+        /* not cancellable: remove close button */
+        progress->setWindowFlags(Qt::Window | Qt::WindowTitleHint |
+                                 Qt::CustomizeWindowHint);
     }
+    progress->setWindowRole ("vlc-progress");
+    progress->setValue(b_indeterminate ? 0 : f_position * 1000);
 
-    delete dialog;
+    vlc_dialog_id_set_context(p_id,
+        new ProgressDialogWrapper(this, p_intf, p_id, progress, b_indeterminate));
+
+    progress->show();
 }
 
-void DialogHandler::requestAnswer (void *value)
+DialogWrapper::DialogWrapper(DialogHandler *p_handler, intf_thread_t *p_intf,
+                             vlc_dialog_id *p_id, QDialog *p_dialog)
+    : QObject()
+    , p_handler(p_handler)
+    , p_intf(p_intf)
+    , p_id(p_id)
+    , p_dialog(p_dialog)
 {
-    dialog_question_t *data = (dialog_question_t *)value;
-
-    QMessageBox *box = new QMessageBox (QMessageBox::Question,
-                                        qfu(data->title), qfu(data->message));
-    QAbstractButton *yes = (data->yes != NULL)
-        ? box->addButton ("&" + qfu(data->yes), QMessageBox::YesRole) : NULL;
-    QAbstractButton *no = (data->no != NULL)
-        ? box->addButton ("&" + qfu(data->no), QMessageBox::NoRole) : NULL;
-    if (data->cancel != NULL)
-        box->addButton ("&" + qfu(data->cancel), QMessageBox::RejectRole);
-
-    box->exec ();
-
-    int answer;
-    if (box->clickedButton () == yes)
-        answer = 1;
-    else
-    if (box->clickedButton () == no)
-        answer = 2;
-    else
-        answer = 3;
-
-    delete box;
-    data->answer = answer;
+    CONNECT(p_dialog, finished(int), this, finish(int));
 }
 
-
-QVLCProgressDialog::QVLCProgressDialog (DialogHandler *parent,
-                                        struct dialog_progress_bar_t *data)
-    : QProgressDialog (qfu(data->message),
-                       data->cancel ? ("&" + qfu(data->cancel)) : 0, 0, 1000),
-      handler (parent),
-      cancelled (false)
+DialogWrapper::~DialogWrapper()
 {
-    if (data->cancel)
-        setWindowModality (Qt::ApplicationModal);
-    if (data->title != NULL)
-        setWindowTitle (qfu(data->title));
-
-    setWindowRole ("vlc-progress");
-    setValue( 0 );
-
-    connect (this, SIGNAL(progressed(int)), SLOT(setValue(int)));
-    connect (this, SIGNAL(described(const QString&)),
-                   SLOT(setLabelText(const QString&)));
-    connect (this, SIGNAL(canceled(void)), SLOT(saveCancel(void)));
-    connect (this, SIGNAL(released(void)), SLOT(deleteLater(void)));
-
-    data->pf_update = update;
-    data->pf_check = check;
-    data->pf_destroy = destroy;
-    data->p_sys = this;
+    p_dialog->hide();
+    delete p_dialog;
 }
 
-void QVLCProgressDialog::update (void *priv, const char *text, float value)
+void DialogWrapper::finish(int result)
 {
-    QVLCProgressDialog *self = static_cast<QVLCProgressDialog *>(priv);
-
-    if (text != NULL)
-        emit self->described (qfu(text));
-    emit self->progressed ((int)(value * 1000.));
+    if (result == QDialog::Rejected && p_id != NULL)
+    {
+        vlc_dialog_id_dismiss(p_id);
+        p_id = NULL;
+    }
+    deleteLater();
 }
 
-static QMutex cancel_mutex;
-
-bool QVLCProgressDialog::check (void *priv)
+LoginDialogWrapper::LoginDialogWrapper(DialogHandler *p_handler,
+                                       intf_thread_t *p_intf, vlc_dialog_id *p_id,
+                                       QDialog *p_dialog, QLineEdit *userLine,
+                                       QLineEdit *passLine, QCheckBox *checkbox)
+    : DialogWrapper(p_handler, p_intf, p_id, p_dialog)
+    , userLine(userLine)
+    , passLine(passLine)
+    , checkbox(checkbox)
 {
-    QVLCProgressDialog *self = static_cast<QVLCProgressDialog *>(priv);
-    QMutexLocker locker (&cancel_mutex);
-    return self->cancelled;
+    CONNECT(p_dialog, accepted(), this, accept());
 }
 
-void QVLCProgressDialog::destroy (void *priv)
+void LoginDialogWrapper::accept()
 {
-    QVLCProgressDialog *self = static_cast<QVLCProgressDialog *>(priv);
-
-    emit self->released ();
+    if (p_id != NULL)
+    {
+        vlc_dialog_id_post_login(p_id, qtu(userLine->text ()),
+                                 qtu(passLine->text ()),
+                                 checkbox != NULL ? checkbox->isChecked () : false);
+        p_id = NULL;
+        if (checkbox != NULL)
+            getSettings()->setValue ("store_password", checkbox->isChecked ());
+    }
 }
 
-void QVLCProgressDialog::saveCancel (void)
+QuestionDialogWrapper::QuestionDialogWrapper(DialogHandler *p_handler,
+                                             intf_thread_t *p_intf,
+                                             vlc_dialog_id *p_id,
+                                             QMessageBox *p_box,
+                                             QAbstractButton *action1,
+                                             QAbstractButton *action2)
+    : DialogWrapper(p_handler, p_intf, p_id, p_box)
+    , action1(action1)
+    , action2(action2)
 {
-    QMutexLocker locker (&cancel_mutex);
-    cancelled = true;
+    CONNECT(p_box, buttonClicked(QAbstractButton *),
+            this, buttonClicked(QAbstractButton *));
 }
 
-void DialogHandler::startProgressBar (void *value)
+void QuestionDialogWrapper::buttonClicked(QAbstractButton *button)
 {
-    dialog_progress_bar_t *data = (dialog_progress_bar_t *)value;
-    QWidget *dlg = new QVLCProgressDialog (this, data);
+    if (p_id != NULL)
+    {
+        if (button == action1)
+            vlc_dialog_id_post_action(p_id, 1);
+        else if (button == action2)
+            vlc_dialog_id_post_action(p_id, 2);
+        else
+            vlc_dialog_id_dismiss(p_id);
+        p_id = NULL;
+    }
+}
 
-    QTimer::singleShot( 1500, dlg, SLOT( show() ) );
-//    dlg->show ();
+ProgressDialogWrapper::ProgressDialogWrapper(DialogHandler *p_handler,
+                                             intf_thread_t *p_intf,
+                                             vlc_dialog_id *p_id,
+                                             QProgressDialog *p_progress,
+                                             bool b_indeterminate)
+    : DialogWrapper(p_handler, p_intf, p_id, p_progress)
+    , b_indeterminate(b_indeterminate)
+{
+    CONNECT(p_progress, canceled(void), this, finish(void));
 }
 
-void DialogHandler::stopProgressBar (QWidget *dlg)
+void ProgressDialogWrapper::updateProgress(float f_position, const QString &text)
 {
-    delete dlg;
+    if (!b_indeterminate)
+    {
+        QProgressDialog *progress = static_cast<QProgressDialog *>(p_dialog);
+        progress->setLabelText(text);
+        progress->setValue(f_position * 1000);
+    }
 }
diff --git a/modules/gui/qt4/dialogs/external.hpp b/modules/gui/qt4/dialogs/external.hpp
index 1a8fe68..2041b63 100644
--- a/modules/gui/qt4/dialogs/external.hpp
+++ b/modules/gui/qt4/dialogs/external.hpp
@@ -26,65 +26,125 @@
 #endif
 
 #include <QObject>
+#include <QDialog>
+#include <QMap>
 #include <vlc_common.h>
+#include <vlc_dialog.h>
 #include "adapters/variables.hpp"
 
 struct intf_thread_t;
 class QProgressDialog;
+class DialogWrapper;
 
 class DialogHandler : public QObject
 {
     Q_OBJECT
 
-    friend class QVLCProgressDialog;
-
 public:
     DialogHandler (intf_thread_t *, QObject *parent);
-    virtual ~DialogHandler (void);
+    virtual ~DialogHandler();
+    void removeDialogId(vlc_dialog_id *p_id);
 
-private:
-    intf_thread_t *p_intf;
-    static int error (vlc_object_t *, const char *, vlc_value_t, vlc_value_t,
-                      void *);
-    QVLCPointer critical;
-    QVLCPointer login;
-    QVLCPointer question;
-    QVLCPointer progressBar;
 signals:
-    void error (const QString&, const QString&);
+    void errorDisplayed(const QString &title, const QString &text);
+    void loginDisplayed(vlc_dialog_id *p_id, const QString &title,
+                        const QString &text, const QString &defaultUsername,
+                        bool b_ask_store);
+    void questionDisplayed(vlc_dialog_id *p_id, const QString &title,
+                           const QString &text, int i_type,
+                           const QString &cancel, const QString &action1,
+                           const QString &action2);
+    void progressDisplayed(vlc_dialog_id *p_id, const QString &title,
+                           const QString &text, bool b_indeterminate,
+                           float f_position, const QString &cancel);
+    void cancelled(vlc_dialog_id *p_id);
+    void progressUpdated(vlc_dialog_id *p_id, float f_value, const QString &text);
 
 private slots:
-    void displayError (const QString&, const QString&);
-    void displayCritical (void *);
-    void requestLogin (void *);
-    void requestAnswer (void *);
-    void startProgressBar (void *);
-    void stopProgressBar (QWidget *);
+    void displayError(const QString &title, const QString &text);
+    void displayLogin(vlc_dialog_id *p_id, const QString &title,
+                      const QString &text, const QString &defaultUsername,
+                      bool b_ask_store);
+    void displayQuestion(vlc_dialog_id *p_id, const QString &title,
+                         const QString &text, int i_type,
+                         const QString &cancel, const QString &action1,
+                         const QString &action2);
+    void displayProgress(vlc_dialog_id *p_id, const QString &title,
+                         const QString &text, bool b_indeterminate,
+                         float f_position, const QString &cancel);
+    void cancel(vlc_dialog_id *p_id);
+    void updateProgress(vlc_dialog_id *p_id, float f_value, const QString &text);
+
+private:
+    intf_thread_t *p_intf;
+
+    static bool displayCb(vlc_dialog_id *, vlc_dialog *, void *);
+    static bool cancelCb(vlc_dialog_id *, void *);
+    static void updateProgressCb(vlc_dialog_id *, float, const char *, void *);
 };
 
-/* Put here instead of .cpp because of MOC */
-#include <QProgressDialog>
+class DialogWrapper : public QObject
+{
+    Q_OBJECT
+
+    friend class DialogHandler;
+public:
+    DialogWrapper(DialogHandler *p_handler, intf_thread_t *p_intf,
+                 vlc_dialog_id *p_id, QDialog *p_dialog);
+    virtual ~DialogWrapper();
+protected slots:
+    virtual void finish(int result = QDialog::Rejected);
+protected:
+    DialogHandler *p_handler;
+    intf_thread_t *p_intf;
+    vlc_dialog_id *p_id;
+    QDialog *p_dialog;
+};
 
-class QVLCProgressDialog : public QProgressDialog
+class QLineEdit;
+class QCheckBox;
+class LoginDialogWrapper : public DialogWrapper
 {
     Q_OBJECT
 public:
-    QVLCProgressDialog (DialogHandler *parent,
-                        struct dialog_progress_bar_t *);
+    LoginDialogWrapper(DialogHandler *p_handler, intf_thread_t *p_intf,
+                       vlc_dialog_id *p_id, QDialog *p_dialog,
+                       QLineEdit *userLine, QLineEdit *passLine,
+                       QCheckBox *checkbox);
+private slots:
+    virtual void accept();
 private:
-    DialogHandler *handler;
-    bool cancelled;
+    QLineEdit *userLine;
+    QLineEdit *passLine;
+    QCheckBox *checkbox;
+};
 
-    static void update (void *, const char *, float);
-    static bool check (void *);
-    static void destroy (void *);
+class QAbstractButton;
+class QMessageBox;
+class QuestionDialogWrapper : public DialogWrapper
+{
+    Q_OBJECT
+public:
+    QuestionDialogWrapper(DialogHandler *p_handler, intf_thread_t *p_intf,
+                          vlc_dialog_id *p_id, QMessageBox *p_box,
+                          QAbstractButton *action1, QAbstractButton *action2);
 private slots:
-    void saveCancel (void);
+    virtual void buttonClicked(QAbstractButton *);
+private:
+    QAbstractButton *action1;
+    QAbstractButton *action2;
+};
 
-signals:
-    void progressed (int);
-    void described (const QString&);
-    void released (void);
+class ProgressDialogWrapper : public DialogWrapper
+{
+    Q_OBJECT
+public:
+    ProgressDialogWrapper(DialogHandler *p_handler, intf_thread_t *p_intf,
+                          vlc_dialog_id *p_id, QProgressDialog  *p_progress,
+                          bool b_indeterminate);
+    void updateProgress(float f_position, const QString &text);
+private:
+    bool b_indeterminate;
 };
 
 #endif
diff --git a/modules/lua/extension.c b/modules/lua/extension.c
index 9546e4c..ea2c8dd 100644
--- a/modules/lua/extension.c
+++ b/modules/lua/extension.c
@@ -964,10 +964,10 @@ int lua_ExecuteFunctionVa( extensions_manager_t *p_mgr, extension_t *p_ext,
 
     // Reset watch timer and timestamp
     vlc_mutex_lock( &p_ext->p_sys->command_lock );
-    if( p_ext->p_sys->progress )
+    if( p_ext->p_sys->p_progress_id != NULL )
     {
-        dialog_ProgressDestroy( p_ext->p_sys->progress );
-        p_ext->p_sys->progress = NULL;
+        vlc_dialog_id_release( p_ext->p_sys->p_progress_id );
+        p_ext->p_sys->p_progress_id = NULL;
     }
     vlc_timer_schedule( p_ext->p_sys->timer, false, 0, 0 );
     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
@@ -1021,10 +1021,10 @@ int lua_ExtensionTriggerMenu( extensions_manager_t *p_mgr,
 
     // Reset watch timer and timestamp
     vlc_mutex_lock( &p_ext->p_sys->command_lock );
-    if( p_ext->p_sys->progress )
+    if( p_ext->p_sys->p_progress_id != NULL )
     {
-        dialog_ProgressDestroy( p_ext->p_sys->progress );
-        p_ext->p_sys->progress = NULL;
+        vlc_dialog_id_release( p_ext->p_sys->p_progress_id );
+        p_ext->p_sys->p_progress_id = NULL;
     }
     vlc_timer_schedule( p_ext->p_sys->timer, false, 0, 0 );
     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
@@ -1106,10 +1106,10 @@ int vlclua_extension_keep_alive( lua_State *L )
     extension_t *p_ext = vlclua_extension_get( L );
 
     vlc_mutex_lock( &p_ext->p_sys->command_lock );
-    if( p_ext->p_sys->progress )
+    if( p_ext->p_sys->p_progress_id != NULL )
     {
-        dialog_ProgressDestroy( p_ext->p_sys->progress );
-        p_ext->p_sys->progress = NULL;
+        vlc_dialog_id_release( p_ext->p_sys->p_progress_id );
+        p_ext->p_sys->p_progress_id = NULL;
     }
     vlc_timer_schedule( p_ext->p_sys->timer, false, WATCH_TIMER_PERIOD, 0 );
     vlc_mutex_unlock( &p_ext->p_sys->command_lock );
@@ -1211,14 +1211,6 @@ static void WatchTimerCallback( void *data )
     extension_t *p_ext = data;
     extensions_manager_t *p_mgr = p_ext->p_sys->p_mgr;
 
-    char *message;
-    if( asprintf( &message, _( "Extension '%s' does not respond.\n"
-                               "Do you want to kill it now? " ),
-                  p_ext->psz_title ) == -1 )
-    {
-        return;
-    }
-
     vlc_mutex_lock( &p_ext->p_sys->command_lock );
 
     for( struct command_t *cmd = p_ext->p_sys->command;
@@ -1226,30 +1218,39 @@ static void WatchTimerCallback( void *data )
          cmd = cmd->next )
         if( cmd->i_command == CMD_DEACTIVATE )
         {   /* We have a pending Deactivate command... */
-            if( p_ext->p_sys->progress )
+            if( p_ext->p_sys->p_progress_id != NULL )
             {
-                dialog_ProgressDestroy( p_ext->p_sys->progress );
-                p_ext->p_sys->progress = NULL;
+                vlc_dialog_id_release( p_ext->p_sys->p_progress_id );
+                p_ext->p_sys->p_progress_id = NULL;
             }
             vlc_mutex_unlock( &p_ext->p_sys->command_lock );
             KillExtension( p_mgr, p_ext );
             return;
         }
 
-    if( !p_ext->p_sys->progress )
+    if( p_ext->p_sys->p_progress_id == NULL )
     {
-        p_ext->p_sys->progress =
-                dialog_ProgressCreate( p_mgr, _( "Extension not responding!" ),
-                                       message,
-                                       _( "Yes" ) );
+        p_ext->p_sys->p_progress_id =
+            vlc_dialog_display_progress( p_mgr, true, 0.0,
+                                         _( "Yes" ),
+                                         _( "Extension not responding!" ),
+                                         _( "Extension '%s' does not respond.\n"
+                                         "Do you want to kill it now? " ),
+                                         p_ext->psz_title );
+        if( p_ext->p_sys->p_progress_id == NULL )
+        {
+            vlc_mutex_unlock( &p_ext->p_sys->command_lock );
+            KillExtension( p_mgr, p_ext );
+            return;
+        }
         vlc_timer_schedule( p_ext->p_sys->timer, false, 100000, 0 );
     }
     else
     {
-        if( dialog_ProgressCancelled( p_ext->p_sys->progress ) )
+        if( vlc_dialog_id_cancelled( p_ext->p_sys->p_progress_id ) )
         {
-            dialog_ProgressDestroy( p_ext->p_sys->progress );
-            p_ext->p_sys->progress = NULL;
+            vlc_dialog_id_release( p_ext->p_sys->p_progress_id );
+            p_ext->p_sys->p_progress_id = NULL;
             vlc_mutex_unlock( &p_ext->p_sys->command_lock );
             KillExtension( p_mgr, p_ext );
             return;
diff --git a/modules/lua/extension.h b/modules/lua/extension.h
index 69f1705..1626334 100644
--- a/modules/lua/extension.h
+++ b/modules/lua/extension.h
@@ -91,7 +91,7 @@ struct extension_sys_t
     } *command;
 
     // The two following booleans are protected by command_lock
-    dialog_progress_bar_t *progress;
+    vlc_dialog_id *p_progress_id;
     vlc_timer_t timer; ///< This timer makes sure Lua never gets stuck >5s
 
     bool b_exiting;
diff --git a/modules/lua/extension_thread.c b/modules/lua/extension_thread.c
index 17d4276..61e88e7 100644
--- a/modules/lua/extension_thread.c
+++ b/modules/lua/extension_thread.c
@@ -149,11 +149,11 @@ int Deactivate( extensions_manager_t *p_mgr, extension_t *p_ext )
         return VLC_EGENERIC;
     }
 
-    if( p_ext->p_sys->progress )
+    if( p_ext->p_sys->p_progress_id != NULL )
     {
         // Extension is stuck, kill it now
-        dialog_ProgressDestroy( p_ext->p_sys->progress );
-        p_ext->p_sys->progress = NULL;
+        vlc_dialog_id_release( p_ext->p_sys->p_progress_id );
+        p_ext->p_sys->p_progress_id = NULL;
         vlc_mutex_unlock( &p_ext->p_sys->command_lock );
         KillExtension( p_mgr, p_ext );
         return VLC_SUCCESS;
diff --git a/modules/misc/gnutls.c b/modules/misc/gnutls.c
index 43ef396..692f901 100644
--- a/modules/misc/gnutls.c
+++ b/modules/misc/gnutls.c
@@ -490,13 +490,13 @@ error:
             goto error;
     }
 
-    if (dialog_Question(creds, _("Insecure site"),
-        _("You attempted to reach %s. %s\n"
-          "This problem may be stem from an attempt to breach your security, "
-          "compromise your privacy, or a configuration error.\n\n"
-          "If in doubt, abort now.\n"),
-                        _("Abort"), _("View certificate"), NULL,
-                        vlc_gettext(msg), host) != 2)
+    if (vlc_dialog_wait_question(creds, VLC_DIALOG_QUESTION_NORMAL,
+            _("Abort"), _("View certificate"), NULL,
+            _("Insecure site"), 
+            _("You attempted to reach %s. %s\n"
+            "This problem may be stem from an attempt to breach your security, "
+            "compromise your privacy, or a configuration error.\n\n"
+            "If in doubt, abort now.\n"), host, vlc_gettext(msg)) != 1)
         goto error;
 
     gnutls_x509_crt_t cert;
@@ -511,20 +511,20 @@ error:
     }
     gnutls_x509_crt_deinit (cert);
 
-    val = dialog_Question(creds, _("Insecure site"),
-         _("This is the certificate presented by %s:\n%s\n\n"
-           "If in doubt, abort now.\n"),
-                          _("Abort"), _("Accept 24 hours"),
-                          _("Accept permanently"), host, desc.data);
+    val = vlc_dialog_wait_question(creds, VLC_DIALOG_QUESTION_NORMAL,
+            _("Abort"), _("Accept 24 hours"), _("Accept permanently"),
+            _("Insecure site"),
+            _("This is the certificate presented by %s:\n%s\n\n"
+            "If in doubt, abort now.\n"), host, desc.data);
     gnutls_free (desc.data);
 
     time_t expiry = 0;
     switch (val)
     {
-        case 2:
+        case 1:
             time (&expiry);
             expiry += 24 * 60 * 60;
-        case 3:
+        case 2:
             val = gnutls_store_pubkey (NULL, NULL, host, service,
                                        GNUTLS_CRT_X509, datum, expiry, 0);
             if (val)
diff --git a/modules/misc/securetransport.c b/modules/misc/securetransport.c
index a313ce2..8e9afc4 100644
--- a/modules/misc/securetransport.c
+++ b/modules/misc/securetransport.c
@@ -330,10 +330,12 @@ static int st_validateServerCertificate (vlc_tls_t *session, const char *hostnam
              "This problem may be caused by a configuration error "
              "or an attempt to breach your security or your privacy.\n\n"
              "If in doubt, abort now.\n");
-    int answer = dialog_Question(session->obj, _("Insecure site"), vlc_gettext (msg),
-                                  _("Abort"), _("Accept certificate temporarily"), NULL, hostname);
-
-    if (answer == 2) {
+    int answer = vlc_dialog_wait_question(session->obj,
+                                          VLC_DIALOG_QUESTION_NORMAL, _("Abort"),
+                                          _("Accept certificate temporarily"),
+                                          NULL, _("Insecure site"),
+                                          vlc_gettext (msg), hostname);
+    if (answer == 1) {
         msg_Warn(session->obj, "Proceeding despite of failed certificate validation");
 
         /* save leaf certificate in whitelist */
diff --git a/modules/text_renderer/freetype/fonts/fontconfig.c b/modules/text_renderer/freetype/fonts/fontconfig.c
index 2c1e5f0..1165b34 100644
--- a/modules/text_renderer/freetype/fonts/fontconfig.c
+++ b/modules/text_renderer/freetype/fonts/fontconfig.c
@@ -54,26 +54,24 @@ int FontConfig_Prepare( filter_t *p_filter )
 #endif
 
 #if defined( _WIN32 )
+    int i_ret;
+    unsigned int i_dialog_id = 0;
     dialog_progress_bar_t *p_dialog = NULL;
     FcConfig *fcConfig = FcInitLoadConfig();
 
-    p_dialog = dialog_ProgressCreate( p_filter,
-            _("Building font cache"),
-            _("Please wait while your font cache is rebuilt.\n"
-                "This should take less than a few minutes."), NULL );
+    i_ret =
+        vlc_dialog_display_progress( p_filter, true, 0.0, NULL,
+                                     _("Building font cache"),
+                                     _("Please wait while your font cache is rebuilt.\n"
+                                     "This should take less than a few minutes.") );
 
-/*    if( p_dialog )
-        dialog_ProgressSet( p_dialog, NULL, 0.5 ); */
+    i_dialog_id = i_ret > 0 ? i_ret : 0;
 
     if( FcConfigBuildFonts( fcConfig ) == FcFalse )
         return VLC_ENOMEM;
 
-    if( p_dialog )
-    {
-//        dialog_ProgressSet( p_dialog, NULL, 1.0 );
-        dialog_ProgressDestroy( p_dialog );
-        p_dialog = NULL;
-    }
+    if( i_dialog_id != 0 )
+        vlc_dialog_cancel( p_filter, i_dialog_id );
 #endif
     t2 = mdate();
     msg_Dbg( p_filter, "Took %ld microseconds", (long)((t2 - t1)) );
diff --git a/src/interface/dialog.c b/src/interface/dialog.c
index 94450db..e0c42c0 100644
--- a/src/interface/dialog.c
+++ b/src/interface/dialog.c
@@ -31,273 +31,745 @@
 
 #include <vlc_common.h>
 #include <vlc_dialog.h>
+#include <vlc_interrupt.h>
 #include <vlc_extensions.h>
 #include <assert.h>
 #include "libvlc.h"
 
-static vlc_mutex_t provider_lock = VLC_STATIC_MUTEX;
+struct vlc_dialog_provider
+{
+    vlc_mutex_t     lock;
+    vlc_array_t     dialog_array;
+    vlc_dialog_cbs  cbs;
+    void *          p_cbs_data;
+};
 
-#undef dialog_Register
-/**
- * Registers an object as the dialog provider.
- * It is assumed that the appropriate variable callbacks are already
- * registered.
- */
-int dialog_Register (vlc_object_t *obj)
+struct dialog_answer
+{
+    vlc_dialog_type i_type;
+    union
+    {
+        struct
+        {
+            char *psz_username;
+            char *psz_password;
+            bool b_store;
+        } login;
+        struct
+        {
+            int i_action;
+        } question;
+    } u;
+};
+
+struct vlc_dialog_id
+{
+    vlc_mutex_t             lock;
+    vlc_cond_t              wait;
+    vlc_dialog_type         i_type;
+    vlc_dialog_provider *   p_provider;
+    void *                  p_context;
+    int                     i_refcount;
+    bool                    b_cancelled;
+    bool                    b_answered;
+    bool                    b_progress_indeterminate;
+    char *                  psz_progress_text;
+    struct dialog_answer    answer;
+};
+
+static inline vlc_dialog_provider *
+get_dialog_provider(vlc_object_t *p_obj, bool b_check_interact)
 {
-    libvlc_priv_t *priv = libvlc_priv (obj->p_libvlc);
-    int ret = VLC_EGENERIC;
+    if (b_check_interact && p_obj->i_flags & OBJECT_FLAGS_NOINTERACT)
+        return NULL;
+    return libvlc_priv(p_obj->p_libvlc)->p_dialog_provider;
+}
 
-    vlc_mutex_lock (&provider_lock);
-    if (priv->p_dialog_provider == NULL)
-    {   /* Since the object is responsible for unregistering itself before
-         * it terminates, at reference is not needed. */
-        priv->p_dialog_provider = obj;
-        ret = VLC_SUCCESS;
+static void
+dialog_id_release(vlc_dialog_id *p_id)
+{
+    if (p_id->answer.i_type == VLC_DIALOG_LOGIN)
+    {
+        free(p_id->answer.u.login.psz_username);
+        free(p_id->answer.u.login.psz_password);
     }
-    vlc_mutex_unlock (&provider_lock);
-    return ret;
+    free(p_id->psz_progress_text);
+    vlc_mutex_destroy(&p_id->lock);
+    vlc_cond_destroy(&p_id->wait);
+    free(p_id);
 }
 
-#undef dialog_Unregister
-/**
- * Unregisters the dialog provider.
- * Note that unless you have unregistered the callbacks already, the provider
- * might still be in use by other threads. Also, you need to cancel all
- * pending dialogs yourself.
- */
-int dialog_Unregister (vlc_object_t *obj)
+#undef dialog_ExtensionUpdate
+int dialog_ExtensionUpdate (vlc_object_t *obj, extension_dialog_t *dialog)
 {
-    libvlc_priv_t *priv = libvlc_priv (obj->p_libvlc);
-    int ret = VLC_EGENERIC;
+    assert (obj);
+    assert (dialog);
 
-    vlc_mutex_lock (&provider_lock);
-    if (priv->p_dialog_provider == obj)
+    vlc_object_t *dp = NULL;//dialog_GetProvider(obj);
+    if (!dp)
     {
-        priv->p_dialog_provider = NULL;
-        ret = VLC_SUCCESS;
+        msg_Warn (obj, "Dialog provider is not set, can't update dialog '%s'",
+                  dialog->psz_title);
+        return VLC_EGENERIC;
     }
-    vlc_mutex_unlock (&provider_lock);
+
+    // Signaling the dialog provider
+    int ret = var_SetAddress (dp, "dialog-extension", dialog);
+
+    vlc_object_release (dp);
     return ret;
 }
 
-static vlc_object_t *dialog_GetProvider (vlc_object_t *obj)
+vlc_dialog_provider *
+vlc_dialog_provider_new(void)
 {
-    libvlc_priv_t *priv = libvlc_priv (obj->p_libvlc);
-    vlc_object_t *provider;
+    vlc_dialog_provider *p_provider = malloc(sizeof(*p_provider));
+    if( p_provider == NULL )
+        return NULL;
+
+    vlc_mutex_init(&p_provider->lock);
+    vlc_array_init(&p_provider->dialog_array);
+
+    memset(&p_provider->cbs, 0, sizeof(p_provider->cbs));
+    p_provider->p_cbs_data = NULL;
 
-    vlc_mutex_lock (&provider_lock);
-    if ((provider = priv->p_dialog_provider) != NULL)
-        vlc_object_hold (provider);
-    vlc_mutex_unlock (&provider_lock);
-    return provider;
+    return p_provider;
 }
 
-/**
- * Sends an error message through the user interface (if any).
- * @param obj the VLC object emitting the error
- * @param modal whether to wait for user to acknowledge the error
- *              before returning control to the caller
- * @param title title of the error dialog
- * @param fmt format string for the error message
- * @param ap parameters list for the formatted error message
- */
-void dialog_VFatal (vlc_object_t *obj, bool modal, const char *title,
-                    const char *fmt, va_list ap)
+static int
+dialog_get_idx_locked(vlc_dialog_provider *p_provider, vlc_dialog_id *p_id)
+{
+    for (int i = 0; i < vlc_array_count(&p_provider->dialog_array); ++i)
+    {
+        if (p_id == vlc_array_item_at_index(&p_provider->dialog_array, i))
+            return i;
+    }
+    return -1;
+}
+
+static bool
+dialog_cancel_locked(vlc_dialog_provider *p_provider, vlc_dialog_id *p_id)
 {
-    char *text;
+    vlc_mutex_lock(&p_id->lock);
+    if (p_id->b_cancelled || p_id->b_answered)
+    {
+        vlc_mutex_unlock(&p_id->lock);
+        return false;
+    }
+    p_id->b_cancelled = true;
+    vlc_mutex_unlock(&p_id->lock);
+
+    bool b_release = true;
+    if (p_provider->cbs.pf_cancel != NULL)
+        b_release = p_provider->cbs.pf_cancel(p_id, p_provider->p_cbs_data);
+    return b_release;
+}
 
-    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)
-        return;
+static void
+dialog_remove_locked(vlc_dialog_provider *p_provider, vlc_dialog_id *p_id,
+                     bool b_force_release)
+{
+    int i_array_idx = dialog_get_idx_locked(p_provider, p_id);
+    assert(i_array_idx >= 0);
+
+    vlc_array_remove(&p_provider->dialog_array, i_array_idx);
+
+    vlc_mutex_lock(&p_id->lock);
+    p_id->i_refcount--;
+    if (p_id->i_refcount == 0 || b_force_release)
+    {
+        vlc_mutex_unlock(&p_id->lock);
+        dialog_id_release(p_id);
+    }
+    else
+        vlc_mutex_unlock(&p_id->lock);
+}
 
-    vlc_object_t *provider = dialog_GetProvider (obj);
-    if (provider == NULL)
+static void
+dialog_clear_all_locked(vlc_dialog_provider *p_provider)
+{
+    for (int i = 0; i < vlc_array_count(&p_provider->dialog_array); ++i)
     {
-        msg_Err (obj, "%s", title);
-        msg_GenericVa (obj, VLC_MSG_ERR, fmt, ap);
-        return;
+        vlc_dialog_id *p_id =
+            vlc_array_item_at_index(&p_provider->dialog_array, i);
+        if (dialog_cancel_locked(p_provider, p_id))
+            dialog_id_release(p_id);
     }
+    vlc_array_clear(&p_provider->dialog_array);
+}
+
+void
+vlc_dialog_provider_release(vlc_dialog_provider *p_provider)
+{
+    assert(p_provider != NULL);
+
+    vlc_mutex_lock(&p_provider->lock);
+    dialog_clear_all_locked(p_provider);
+    vlc_mutex_unlock(&p_provider->lock);
 
-    if (vasprintf (&text, fmt, ap) != -1)
+    vlc_mutex_destroy(&p_provider->lock);
+    free(p_provider);
+}
+
+#undef vlc_dialog_provider_set_callbacks
+void
+vlc_dialog_provider_set_callbacks(vlc_object_t *p_obj,
+                                  vlc_dialog_cbs *p_cbs, void *p_data)
+{
+    assert(p_obj != NULL);
+    vlc_dialog_provider *p_provider = get_dialog_provider(p_obj, false);
+    assert(p_provider != NULL);
+
+    vlc_mutex_lock(&p_provider->lock);
+    dialog_clear_all_locked(p_provider);
+
+    if (p_cbs == NULL)
     {
-        dialog_fatal_t dialog = { title, text, };
-        var_SetAddress (provider,
-                        modal ? "dialog-critical" : "dialog-error", &dialog);
-        free (text);
+        memset(&p_provider->cbs, 0, sizeof(p_provider->cbs));
+        p_provider->p_cbs_data = NULL;
     }
-    vlc_object_release (provider);
+    else
+    {
+        p_provider->cbs = *p_cbs;
+        p_provider->p_cbs_data = p_data;
+    }
+    vlc_mutex_unlock(&p_provider->lock);
 }
 
-#undef dialog_vaLogin
-void dialog_vaLogin (vlc_object_t *obj, const char *default_username,
-                   char **username, char **password, bool *store,
-                   const char *title, const char *fmt, va_list ap)
+static void
+dialog_wait_interrupted(void *p_data)
 {
-    assert ((username != NULL) && (password != NULL));
+    vlc_dialog_id *p_id = p_data;
+    vlc_dialog_provider *p_provider = p_id->p_provider;
+
+    vlc_mutex_lock(&p_provider->lock);
+    bool b_release = dialog_cancel_locked(p_provider, p_id);
+    vlc_mutex_unlock(&p_provider->lock);
+printf("dialog_wait_interrupted: %d\n", b_release);
+
+    vlc_mutex_lock(&p_id->lock);
+    if (b_release)
+        p_id->i_refcount--;
+    vlc_cond_signal(&p_id->wait);
+    vlc_mutex_unlock(&p_id->lock);
+}
 
-    *username = *password = NULL;
-    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)
-        return;
+static int
+dialog_wait(vlc_dialog_provider *p_provider, vlc_dialog_id *p_id,
+            vlc_dialog_type i_type, struct dialog_answer *p_answer)
+{
+    vlc_interrupt_register(dialog_wait_interrupted, p_id);
+
+    vlc_mutex_lock(&p_id->lock);
+    /* Wait for the dialog to be dismissed, interrupted or answered */
+    while (!p_id->b_cancelled && !p_id->b_answered)
+        vlc_cond_wait(&p_id->wait, &p_id->lock);
+
+    int i_ret;
+    if (p_id->b_cancelled)
+        i_ret = 0;
+    else if (p_id->answer.i_type != i_type)
+        i_ret = VLC_EGENERIC;
+    else
+    {
+        i_ret = 1;
+        *p_answer = p_id->answer;
+        memset(&p_id->answer, 0, sizeof(p_id->answer));
+    }
 
-    vlc_object_t *provider = dialog_GetProvider (obj);
-    if (provider == NULL)
-        return;
+    vlc_mutex_unlock(&p_id->lock);
+    vlc_interrupt_unregister();
 
-    char *text;
+    vlc_mutex_lock(&p_provider->lock);
+    dialog_remove_locked(p_provider, p_id, false);
+    vlc_mutex_unlock(&p_provider->lock);
+    return i_ret;
+}
 
-    if (vasprintf (&text, fmt, ap) != -1)
+static int
+dialog_display(vlc_dialog_provider *p_provider, vlc_dialog_id **pp_id,
+               vlc_dialog *p_dialog)
+{
+    vlc_dialog_id *p_id = NULL;
+
+    vlc_mutex_lock(&p_provider->lock);
+    if (p_provider->cbs.pf_display == NULL)
     {
-        dialog_login_t dialog = { title, text, default_username, username,
-                                  password, store };
-        var_SetAddress (provider, "dialog-login", &dialog);
-        free (text);
+        vlc_mutex_unlock(&p_provider->lock);
+        return VLC_EGENERIC;
     }
-    vlc_object_release (provider);
+
+    if (pp_id != NULL)
+    {
+        p_id = calloc(1, sizeof(*p_id));
+        vlc_mutex_init(&p_id->lock);
+        vlc_cond_init(&p_id->wait);
+        if (p_id == NULL)
+        {
+            vlc_mutex_unlock(&p_provider->lock);
+            return VLC_ENOMEM;
+        }
+
+        p_id->p_provider = p_provider;
+        p_id->i_type = p_dialog->i_type;
+        p_id->i_refcount = 2; /* provider and callbacks */
+
+        vlc_array_append(&p_provider->dialog_array, p_id);
+    }
+
+    if (!p_provider->cbs.pf_display(p_id, p_dialog, p_provider->p_cbs_data)
+     && p_id != NULL)
+    {
+        dialog_remove_locked(p_provider, p_id, true);
+        p_id = NULL;
+    }
+    if (pp_id != NULL)
+        *pp_id = p_id;
+
+    vlc_mutex_unlock(&p_provider->lock);
+
+    return VLC_SUCCESS;
 }
 
-#undef dialog_Login
-/**
- * Requests a username and password through the user interface.
- * @param obj the VLC object requesting credential information
- * @param username a pointer to the specified username [OUT]
- * @param password a pointer to the specified password [OUT]
- * @param title title for the dialog
- * @param fmt format string for the message in the dialog
- * @return Nothing. If a user name resp. a password was specified,
- * it will be returned as a heap-allocated character array
- * into the username resp password pointer. Those must be freed with free().
- * Otherwise *username resp *password will be NULL.
- */
-void dialog_Login (vlc_object_t *obj, const char *default_username,
-                   char **username, char **password,
-                   bool *store, const char *title, const char *fmt, ...)
+static int
+dialog_display_error_va(vlc_dialog_provider *p_provider, const char *psz_title,
+                        const char *psz_fmt, va_list ap)
+{
+    char *psz_text;
+    if (vasprintf(&psz_text, psz_fmt, ap) == -1)
+        return VLC_ENOMEM;
+
+    vlc_dialog dialog = {
+        .i_type = VLC_DIALOG_ERROR,
+        .psz_title = psz_title,
+        .psz_text = psz_text,
+    };
+
+    int i_ret = dialog_display(p_provider, NULL, &dialog);
+    free(psz_text);
+    return i_ret;
+}
+
+int
+vlc_dialog_display_error_va(vlc_object_t *p_obj, const char *psz_title,
+                            const char *psz_fmt, va_list ap)
 {
+    assert(p_obj != NULL && psz_title != NULL && psz_fmt != NULL);
+    vlc_dialog_provider *p_provider = get_dialog_provider(p_obj, true);
+    if (p_provider == NULL)
+        return VLC_EGENERIC;
+
+    return dialog_display_error_va(p_provider, psz_title, psz_fmt, ap);
+}
+
+
+#undef vlc_dialog_display_error
+int
+vlc_dialog_display_error(vlc_object_t *p_obj, const char *psz_title,
+                         const char *psz_fmt, ...)
+{
+    assert(psz_fmt != NULL);
     va_list ap;
-    va_start (ap, fmt);
-    dialog_vaLogin (obj, default_username, username, password, store,
-                    title, fmt, ap);
-    va_end (ap);
+    va_start(ap, psz_fmt);
+    int i_ret = vlc_dialog_display_error_va(p_obj, psz_title, psz_fmt, ap);
+    va_end(ap);
+    return i_ret;
 }
 
-#undef dialog_Question
-/**
- * Asks a total (Yes/No/Cancel) question through the user interface.
- * @param obj VLC object emitting the question
- * @param title dialog box title
- * @param fmt format string for the dialog box text
- * @param yes first choice/button text
- * @param no second choice/button text
- * @param cancel third answer/button text, or NULL if no third option
- * @return 0 if the user could not answer the question (e.g. there is no UI),
- * 1, 2 resp. 3 if the user pressed the first, second resp. third button.
- */
-int dialog_Question (vlc_object_t *obj, const char *title, const char *fmt,
-                     const char *yes, const char *no, const char *cancel, ...)
+static int
+dialog_display_login_va(vlc_dialog_provider *p_provider, vlc_dialog_id **pp_id,
+                        const char *psz_default_username, bool b_ask_store,
+                        const char *psz_title, const char *psz_fmt, va_list ap)
 {
-    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)
-        return 0;
+    char *psz_text;
+    if (vasprintf(&psz_text, psz_fmt, ap) == -1)
+        return VLC_ENOMEM;
+
+    vlc_dialog dialog = {
+        .i_type = VLC_DIALOG_LOGIN,
+        .psz_title = psz_title,
+        .psz_text = psz_text,
+        .u.login = {
+            .psz_default_username = psz_default_username,
+            .b_ask_store = b_ask_store,
+        }
+    };
+
+    int i_ret = dialog_display(p_provider, pp_id, &dialog);
+    free(psz_text);
+    return i_ret;
+}
 
-    vlc_object_t *provider = dialog_GetProvider (obj);
-    if (provider == NULL)
-        return 0;
+int
+vlc_dialog_wait_login_va(vlc_object_t *p_obj,  char **ppsz_username,
+                         char **ppsz_password, bool *p_store,
+                         const char *psz_default_username,
+                         const char *psz_title, const char *psz_fmt, va_list ap)
+{
+    assert(p_obj != NULL && ppsz_username != NULL && ppsz_password != NULL
+        && psz_fmt != NULL && psz_title != NULL);
 
-    char *text;
+    vlc_dialog_provider *p_provider = get_dialog_provider(p_obj, true);
+    if (p_provider == NULL)
+        return VLC_EGENERIC;
+
+    vlc_dialog_id *p_id;
+    int i_ret = dialog_display_login_va(p_provider, &p_id, psz_default_username,
+                                        p_store != NULL, psz_title, psz_fmt, ap);
+    if (i_ret < 0 || p_id == NULL)
+        return i_ret;
+
+    struct dialog_answer answer;
+    i_ret = dialog_wait(p_provider, p_id, VLC_DIALOG_LOGIN, &answer);
+    if (i_ret <= 0)
+        return i_ret;
+
+    *ppsz_username = answer.u.login.psz_username;
+    *ppsz_password = answer.u.login.psz_password;
+    if (p_store != NULL)
+        *p_store = answer.u.login.b_store;
+
+    return 1;
+}
+
+#undef vlc_dialog_wait_login
+int
+vlc_dialog_wait_login(vlc_object_t *p_obj,  char **ppsz_username,
+                      char **ppsz_password, bool *p_store,
+                      const char *psz_default_username, const char *psz_title,
+                      const char *psz_fmt, ...)
+{
+    assert(psz_fmt != NULL);
     va_list ap;
-    int answer = 0;
+    va_start(ap, psz_fmt);
+    int i_ret = vlc_dialog_wait_login_va(p_obj, ppsz_username, ppsz_password,
+                                         p_store,psz_default_username,
+                                         psz_title, psz_fmt, ap);
+    va_end(ap);
+    return i_ret;
+}
+
+static int
+dialog_display_question_va(vlc_dialog_provider *p_provider, vlc_dialog_id **pp_id,
+                           vlc_dialog_question_type i_type,
+                           const char *psz_cancel, const char *psz_action1,
+                           const char *psz_action2, const char *psz_title,
+                           const char *psz_fmt, va_list ap)
+{
+    char *psz_text;
+    if (vasprintf(&psz_text, psz_fmt, ap) == -1)
+        return VLC_ENOMEM;
+
+    vlc_dialog dialog = {
+        .i_type = VLC_DIALOG_QUESTION,
+        .psz_title = psz_title,
+        .psz_text = psz_text,
+        .u.question = {
+            .i_type = i_type,
+            .psz_cancel = psz_cancel,
+            .psz_action1 = psz_action1,
+            .psz_action2 = psz_action2,
+        }
+    };
+
+    int i_ret = dialog_display(p_provider, pp_id, &dialog);
+    free(psz_text);
+    return i_ret;
+}
 
-    va_start (ap, cancel);
-    if (vasprintf (&text, fmt, ap) != -1)
+int
+vlc_dialog_wait_question_va(vlc_object_t *p_obj,
+                            vlc_dialog_question_type i_type,
+                            const char *psz_cancel, const char *psz_action1,
+                            const char *psz_action2, const char *psz_title,
+                            const char *psz_fmt, va_list ap)
+{
+    assert(p_obj != NULL && psz_fmt != NULL && psz_title != NULL
+        && psz_cancel != NULL);
+
+    vlc_dialog_provider *p_provider = get_dialog_provider(p_obj, true);
+    if (p_provider == NULL)
+        return VLC_EGENERIC;
+
+    vlc_dialog_id *p_id;
+    int i_ret = dialog_display_question_va(p_provider, &p_id, i_type,
+                                           psz_cancel, psz_action1,
+                                           psz_action2, psz_title, psz_fmt, ap);
+    if (i_ret < 0 || p_id == NULL)
+        return i_ret;
+
+    struct dialog_answer answer;
+    i_ret = dialog_wait(p_provider, p_id, VLC_DIALOG_QUESTION, &answer);
+    if (i_ret <= 0)
+        return i_ret;
+
+    if (answer.u.question.i_action != 1 && answer.u.question.i_action != 2)
+        return VLC_EGENERIC;
+
+    return answer.u.question.i_action;
+}
+
+#undef vlc_dialog_wait_question
+int
+vlc_dialog_wait_question(vlc_object_t *p_obj,
+                         vlc_dialog_question_type i_type,
+                         const char *psz_cancel, const char *psz_action1,
+                         const char *psz_action2, const char *psz_title,
+                         const char *psz_fmt, ...)
+{
+    assert(psz_fmt != NULL);
+    va_list ap;
+    va_start(ap, psz_fmt);
+    int i_ret = vlc_dialog_wait_question_va(p_obj, i_type, psz_cancel,
+                                            psz_action1, psz_action2, psz_title,
+                                            psz_fmt, ap);
+    va_end(ap);
+    return i_ret;
+}
+
+static int
+display_progress_va(vlc_dialog_provider *p_provider, vlc_dialog_id **pp_id,
+                    bool b_indeterminate, float f_position,
+                    const char *psz_cancel, const char *psz_title,
+                    const char *psz_fmt, va_list ap)
+{
+    char *psz_text;
+    if (vasprintf(&psz_text, psz_fmt, ap) == -1)
+        return VLC_ENOMEM;
+
+    vlc_dialog dialog = {
+        .i_type = VLC_DIALOG_PROGRESS,
+        .psz_title = psz_title,
+        .psz_text = psz_text,
+        .u.progress = {
+            .b_indeterminate = b_indeterminate,
+            .f_position = f_position,
+            .psz_cancel = psz_cancel,
+        }
+    };
+
+    int i_ret = dialog_display(p_provider, pp_id, &dialog);
+    if (i_ret == VLC_SUCCESS && *pp_id != NULL)
     {
-        dialog_question_t dialog = { title, text, yes, no, cancel, 0, };
-        var_SetAddress (provider, "dialog-question", &dialog);
-        answer = dialog.answer;
-        free (text);
+        vlc_dialog_id *p_id = *pp_id;
+        vlc_mutex_lock(&p_provider->lock);
+        p_id->b_progress_indeterminate = b_indeterminate;
+        p_id->psz_progress_text = psz_text;
+        psz_text = NULL;
+        vlc_mutex_unlock(&p_provider->lock);
     }
-    va_end (ap);
-    vlc_object_release (provider);
-    return answer;
+    free(psz_text);
+    return i_ret;
 }
 
-#undef dialog_ProgressCreate
-/**
- * Creates a progress bar dialog.
- */
-dialog_progress_bar_t *
-dialog_ProgressCreate (vlc_object_t *obj, const char *title,
-                       const char *message, const char *cancel)
+vlc_dialog_id *
+vlc_dialog_display_progress_va(vlc_object_t *p_obj, bool b_indeterminate,
+                               float f_position, const char *psz_cancel,
+                               const char *psz_title, const char *psz_fmt,
+                               va_list ap)
 {
-    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)
-        return NULL;
+    assert(p_obj != NULL && psz_title != NULL && psz_fmt != NULL);
 
-    vlc_object_t *provider = dialog_GetProvider (obj);
-    if (provider == NULL)
+    vlc_dialog_provider *p_provider = get_dialog_provider(p_obj, true);
+    if (p_provider == NULL)
         return NULL;
+    vlc_dialog_id *p_id;
+    int i_ret = display_progress_va(p_provider, &p_id, b_indeterminate,
+                                    f_position, psz_cancel, psz_title, psz_fmt,
+                                    ap);
+    return i_ret == VLC_SUCCESS ? p_id : NULL;
+}
+
+#undef vlc_dialog_display_progress
+vlc_dialog_id *
+vlc_dialog_display_progress(vlc_object_t *p_obj, bool b_indeterminate,
+                            float f_position, const char *psz_cancel,
+                            const char *psz_title, const char *psz_fmt, ...)
+{
+    assert(psz_fmt != NULL);
+    va_list ap;
+    va_start(ap, psz_fmt);
+    vlc_dialog_id *p_id =
+        vlc_dialog_display_progress_va(p_obj, b_indeterminate, f_position,
+                                       psz_cancel, psz_title, psz_fmt, ap);
+    va_end(ap);
+    return p_id;
+}
 
-    dialog_progress_bar_t *dialog = malloc (sizeof (*dialog));
-    if (dialog != NULL)
+static int
+dialog_id_update_progress(vlc_dialog_id *p_id, float f_value, char *psz_text)
+{
+    assert(p_id != NULL);
+    vlc_dialog_provider *p_provider = p_id->p_provider;
+    assert(p_provider != NULL);
+
+    vlc_mutex_lock(&p_provider->lock);
+    if (p_provider->cbs.pf_update_progress == NULL)
     {
-        dialog->title = title;
-        dialog->message = message;
-        dialog->cancel = cancel;
-        var_SetAddress (provider, "dialog-progress-bar", dialog);
-#ifndef NDEBUG
-        dialog->title = dialog->message = dialog->cancel = NULL;
-#endif
-        assert (dialog->pf_update);
-        assert (dialog->pf_check);
-        assert (dialog->pf_destroy);
+        vlc_mutex_unlock(&p_provider->lock);
+        free(psz_text);
+        return VLC_EGENERIC;
     }
 
-    /* FIXME: This could conceivably crash if the dialog provider is destroyed
-     * before the dialog user. Holding the provider does not help, as it only
-     * protects object variable operations. For instance, it does not prevent
-     * unloading of the interface plugin. In the short term, the only solution
-     * is to not use progress dialog after deinitialization of the interfaces.
-     */
-    vlc_object_release (provider);
-    return dialog;
+    if (p_id->b_progress_indeterminate)
+    {
+        vlc_mutex_unlock(&p_provider->lock);
+        free(psz_text);
+        return VLC_EGENERIC;
+    }
+    if (psz_text != NULL)
+    {
+        free(p_id->psz_progress_text);
+        p_id->psz_progress_text = psz_text;
+    }
+    p_provider->cbs.pf_update_progress(p_id, f_value, p_id->psz_progress_text,
+                                       p_provider->p_cbs_data);
+
+    vlc_mutex_unlock(&p_provider->lock);
+    return VLC_SUCCESS;
 }
 
-void dialog_ProgressDestroy (dialog_progress_bar_t *dialog)
+int
+vlc_dialog_id_update_progress(vlc_dialog_id *p_id, float f_value)
 {
-    assert (dialog);
+    assert(p_id!= NULL);
 
-    dialog->pf_destroy (dialog->p_sys);
-    free (dialog);
+    return dialog_id_update_progress(p_id, f_value, NULL);
 }
 
-void dialog_ProgressSet (dialog_progress_bar_t *dialog, const char *text,
-                         float value)
+int
+vlc_dialog_id_update_progress_text_va(vlc_dialog_id *p_id, float f_value,
+                                      const char *psz_fmt, va_list ap)
 {
-    assert (dialog);
+    assert(p_id != NULL);
 
-    dialog->pf_update (dialog->p_sys, text, value);
+    char *psz_text;
+    if (vasprintf(&psz_text, psz_fmt, ap) == -1)
+        return VLC_ENOMEM;
+    return dialog_id_update_progress(p_id, f_value, psz_text);
 }
 
-bool dialog_ProgressCancelled (dialog_progress_bar_t *dialog)
+int
+vlc_dialog_id_update_progress_text(vlc_dialog_id *p_id, float f_value,
+                                   const char *psz_fmt, ...)
 {
-    assert (dialog);
+    assert(psz_fmt != NULL);
+    va_list ap;
+    va_start(ap, psz_fmt);
+    int i_ret = vlc_dialog_id_update_progress_text_va(p_id, f_value, psz_fmt, ap);
+    va_end(ap);
+    return i_ret;
+}
 
-    return dialog->pf_check (dialog->p_sys);
+void
+vlc_dialog_id_release(vlc_dialog_id *p_id)
+{
+    assert(p_id != NULL);
+    vlc_dialog_provider *p_provider = p_id->p_provider;
+    assert(p_provider != NULL);
+
+    vlc_mutex_lock(&p_provider->lock);
+    bool b_release = dialog_cancel_locked(p_provider, p_id);
+    dialog_remove_locked(p_provider, p_id, b_release);
+    vlc_mutex_unlock(&p_provider->lock);
 }
 
-#undef dialog_ExtensionUpdate
-int dialog_ExtensionUpdate (vlc_object_t *obj, extension_dialog_t *dialog)
+bool
+vlc_dialog_id_cancelled(vlc_dialog_id *p_id)
 {
-    assert (obj);
-    assert (dialog);
+    assert(p_id != NULL);
 
-    vlc_object_t *dp = dialog_GetProvider(obj);
-    if (!dp)
+    vlc_mutex_lock(&p_id->lock);
+    bool b_cancelled = p_id->b_cancelled;
+    vlc_mutex_unlock(&p_id->lock);
+    return b_cancelled;
+}
+
+void
+vlc_dialog_id_set_context(vlc_dialog_id *p_id, void *p_context)
+{
+    vlc_mutex_lock(&p_id->lock);
+    p_id->p_context = p_context;
+    vlc_mutex_unlock(&p_id->lock);
+}
+
+void *
+vlc_dialog_id_get_context(vlc_dialog_id *p_id)
+{
+    vlc_mutex_lock(&p_id->lock);
+    void *p_context = p_id->p_context;
+    vlc_mutex_unlock(&p_id->lock);
+    return p_context;
+}
+
+static int
+dialog_id_post(vlc_dialog_id *p_id, struct dialog_answer *p_answer)
+{
+    vlc_mutex_lock(&p_id->lock);
+    if (p_answer == NULL)
     {
-        msg_Warn (obj, "Dialog provider is not set, can't update dialog '%s'",
-                  dialog->psz_title);
-        return VLC_EGENERIC;
+        p_id->b_cancelled = true;
     }
+    else
+    {
+        p_id->answer = *p_answer;
+        p_id->b_answered = true;
+    }
+    p_id->i_refcount--;
+    if (p_id->i_refcount > 0)
+    {
+        vlc_cond_signal(&p_id->wait);
+        vlc_mutex_unlock(&p_id->lock);
+    }
+    else
+    {
+        vlc_mutex_unlock(&p_id->lock);
+        dialog_id_release(p_id);
+    }
+    return VLC_SUCCESS;
+}
 
-    // Signaling the dialog provider
-    int ret = var_SetAddress (dp, "dialog-extension", dialog);
+int
+vlc_dialog_id_post_login(vlc_dialog_id *p_id, const char *psz_username,
+                         const char *psz_password, bool b_store)
+{
+    assert(p_id != NULL && psz_username != NULL && psz_password != NULL);
+
+    struct dialog_answer answer = {
+        .i_type = VLC_DIALOG_LOGIN,
+        .u.login = {
+            .b_store = b_store,
+            .psz_username = strdup(psz_username),
+            .psz_password = strdup(psz_password),
+        },
+    };
+    if (answer.u.login.psz_username == NULL
+     || answer.u.login.psz_password == NULL)
+    {
+        free(answer.u.login.psz_username);
+        free(answer.u.login.psz_password);
+        dialog_id_post(p_id, NULL);
+        return VLC_ENOMEM;
+    }
 
-    vlc_object_release (dp);
-    return ret;
+    return dialog_id_post(p_id, &answer);
+}
+
+int
+vlc_dialog_id_post_action(vlc_dialog_id *p_id, int i_action)
+{
+    assert(p_id != NULL);
+
+    struct dialog_answer answer = {
+        .i_type = VLC_DIALOG_QUESTION,
+        .u.question = { .i_action = i_action },
+    };
+
+    return dialog_id_post(p_id, &answer);
+}
+
+int
+vlc_dialog_id_dismiss(vlc_dialog_id *p_id)
+{
+    return dialog_id_post(p_id, NULL);
 }
diff --git a/src/libvlc.c b/src/libvlc.c
index a7d9a69..964e586 100644
--- a/src/libvlc.c
+++ b/src/libvlc.c
@@ -61,6 +61,7 @@
 #include <vlc_interface.h>
 
 #include <vlc_charset.h>
+#include <vlc_dialog.h>
 #include <vlc_fs.h>
 #include <vlc_cpu.h>
 #include <vlc_url.h>
@@ -235,6 +236,14 @@ int libvlc_InternalInit( libvlc_int_t *p_libvlc, int i_argc,
     }
 #endif
 
+    priv->p_dialog_provider = vlc_dialog_provider_new();
+    if( priv->p_dialog_provider == NULL )
+    {
+        vlc_LogDeinit (p_libvlc);
+        module_EndBank (true);
+        return VLC_ENOMEM;
+    }
+
 /* FIXME: could be replaced by using Unix sockets */
 #ifdef HAVE_DBUS
 
@@ -503,6 +512,8 @@ void libvlc_InternalCleanup( libvlc_int_t *p_libvlc )
     libvlc_Quit( p_libvlc );
     intf_DestroyAll( p_libvlc );
 
+    vlc_dialog_provider_release( priv->p_dialog_provider );
+
 #ifdef ENABLE_VLM
     /* Destroy VLM if created in libvlc_InternalInit */
     if( priv->p_vlm )
diff --git a/src/libvlc.h b/src/libvlc.h
index e18ee37..d198581 100644
--- a/src/libvlc.h
+++ b/src/libvlc.h
@@ -138,6 +138,8 @@ module_t *module_find_by_shortcut (const char *psz_shortcut);
 /**
  * Private LibVLC instance data.
  */
+typedef struct vlc_dialog_provider vlc_dialog_provider;
+
 typedef struct libvlc_priv_t
 {
     libvlc_int_t       public_data;
@@ -148,7 +150,7 @@ typedef struct libvlc_priv_t
     /* Singleton objects */
     vlc_logger_t      *logger;
     vlm_t             *p_vlm;  ///< the VLM singleton (or NULL)
-    vlc_object_t      *p_dialog_provider; ///< dialog provider
+    vlc_dialog_provider *p_dialog_provider; ///< dialog provider
     struct playlist_t *playlist; ///< Playlist for interfaces
     struct playlist_preparser_t *parser; ///< Input item meta data handler
     struct vlc_actions *actions; ///< Hotkeys handler
diff --git a/src/libvlccore.sym b/src/libvlccore.sym
index 62ef785..2043903 100644
--- a/src/libvlccore.sym
+++ b/src/libvlccore.sym
@@ -95,16 +95,6 @@ demux_New
 demux_vaControl
 demux_vaControlHelper
 dialog_ExtensionUpdate
-dialog_Login
-dialog_vaLogin
-dialog_ProgressCancelled
-dialog_ProgressCreate
-dialog_ProgressDestroy
-dialog_ProgressSet
-dialog_Question
-dialog_Register
-dialog_Unregister
-dialog_VFatal
 EndMD5
 es_format_Clean
 es_format_Copy
@@ -526,6 +516,27 @@ vlc_credential_init
 vlc_credential_clean
 vlc_credential_get
 vlc_credential_store
+vlc_dialog_display_error
+vlc_dialog_display_error_va
+vlc_dialog_display_progress
+vlc_dialog_display_progress_va
+vlc_dialog_id_cancelled
+vlc_dialog_id_dismiss
+vlc_dialog_id_get_context
+vlc_dialog_id_post_action
+vlc_dialog_id_post_login
+vlc_dialog_id_release
+vlc_dialog_id_set_context
+vlc_dialog_id_update_progress
+vlc_dialog_id_update_progress_text
+vlc_dialog_id_update_progress_text_va
+vlc_dialog_provider_new
+vlc_dialog_provider_release
+vlc_dialog_provider_set_callbacks
+vlc_dialog_wait_login
+vlc_dialog_wait_login_va
+vlc_dialog_wait_question
+vlc_dialog_wait_question_va
 vlc_sem_init
 vlc_sem_destroy
 vlc_sem_post
diff --git a/src/misc/keystore.c b/src/misc/keystore.c
index 62c7603..638fab5 100644
--- a/src/misc/keystore.c
+++ b/src/misc/keystore.c
@@ -395,37 +395,38 @@ vlc_credential_get(vlc_credential *p_credential, vlc_object_t *p_parent,
                 return false;
             char *psz_dialog_username = NULL;
             char *psz_dialog_password = NULL;
-
             va_list ap;
             va_start(ap, psz_dialog_fmt);
-            dialog_vaLogin(p_parent, p_credential->psz_username,
-                           &psz_dialog_username, &psz_dialog_password,
-                           p_credential->p_keystore ? &p_credential->b_store : NULL,
-                           psz_dialog_title, psz_dialog_fmt, ap);
+            bool *p_store = p_credential->p_keystore != NULL ?
+                            &p_credential->b_store : NULL;
+            int i_ret =
+                vlc_dialog_wait_login_va(p_parent,
+                                         &psz_dialog_username,
+                                         &psz_dialog_password, p_store,
+                                         p_credential->psz_username,
+                                         psz_dialog_title, psz_dialog_fmt, ap);
             va_end(ap);
 
-            /* Free previous dialog strings after dialog_vaLogin call since
-             * p_credential->psz_username (default username) can be a pointer
-             * to p_credential->psz_dialog_username */
+            /* Free previous dialog strings after vlc_dialog_wait_login_va call
+             * since p_credential->psz_username (default username) can be a
+             * pointer to p_credential->psz_dialog_username */
             free(p_credential->psz_dialog_username);
             free(p_credential->psz_dialog_password);
             p_credential->psz_dialog_username = psz_dialog_username;
             p_credential->psz_dialog_password = psz_dialog_password;
 
-            if (p_credential->psz_dialog_username
-             && p_credential->psz_dialog_password)
-            {
-                p_credential->psz_username = p_credential->psz_dialog_username;
-                p_credential->psz_password = p_credential->psz_dialog_password;
-
-                if (protocol_is_smb(p_url))
-                    smb_split_domain(p_credential);
-            }
-            else
+            if (i_ret != 1)
             {
                 p_credential->psz_username = p_credential->psz_password = NULL;
                 return false;
             }
+
+            p_credential->psz_username = p_credential->psz_dialog_username;
+            p_credential->psz_password = p_credential->psz_dialog_password;
+
+            if (protocol_is_smb(p_url))
+                smb_split_domain(p_credential);
+
             break;
         }
     }
diff --git a/src/misc/update.c b/src/misc/update.c
index 1d7f765..a5f14e1 100644
--- a/src/misc/update.c
+++ b/src/misc/update.c
@@ -88,6 +88,10 @@
 # define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status" UPDATE_OS_SUFFIX
 #endif
 
+#define dialog_FatalWait( p_obj, psz_title, psz_fmt, ... ) \
+    vlc_dialog_wait_question( p_obj, VLC_DIALOG_QUESTION_CRITICAL, "OK", NULL, \
+                              NULL, psz_title, psz_fmt, ##__VA_ARGS__ );
+
 /*****************************************************************************
  * Update_t functions
  *****************************************************************************/
@@ -525,11 +529,11 @@ void update_Download( update_t *p_update, const char *psz_destdir )
 static void* update_DownloadReal( void *obj )
 {
     update_download_thread_t *p_udt = (update_download_thread_t *)obj;
-    dialog_progress_bar_t *p_progress = NULL;
+    int i_ret;
+    unsigned int i_dialog_id = 0;
     uint64_t l_size;
     uint64_t l_downloaded = 0;
     float f_progress;
-    char *psz_status;
     char *psz_downloaded = NULL;
     char *psz_size = NULL;
     char *psz_destfile = NULL;
@@ -589,20 +593,21 @@ static void* update_DownloadReal( void *obj )
     msg_Dbg( p_udt, "Downloading Stream '%s'", p_update->release.psz_url );
 
     psz_size = size_str( l_size );
-    if( asprintf( &psz_status, _("%s\nDownloading... %s/%s %.1f%% done"),
-        p_update->release.psz_url, "0.0", psz_size, 0.0 ) == -1 )
-        goto end;
 
-    p_progress = dialog_ProgressCreate( p_udt, _( "Downloading..."),
-                                        psz_status, _("Cancel") );
+    i_ret =
+        vlc_dialog_display_progress( p_udt, false, 0.0, _("Cancel"),
+                                     ( "Downloading..."),
+                                     _("%s\nDownloading... %s/%s %.1f%% done"),
+                                     p_update->release.psz_url, "0.0", psz_size,
+                                     0.0 );
 
-    free( psz_status );
-    if( p_progress == NULL )
+    if( i_ret <= 0 )
         goto end;
+    i_dialog_id = i_ret;
 
     while( !atomic_load( &p_udt->aborted ) &&
            ( i_read = stream_Read( p_stream, p_buffer, 1 << 10 ) ) &&
-           !dialog_ProgressCancelled( p_progress ) )
+           !vlc_dialog_cancelled( p_udt, i_dialog_id ) )
     {
         if( fwrite( p_buffer, i_read, 1, p_file ) < 1 )
         {
@@ -614,13 +619,11 @@ static void* update_DownloadReal( void *obj )
         psz_downloaded = size_str( l_downloaded );
         f_progress = (float)l_downloaded/(float)l_size;
 
-        if( asprintf( &psz_status, _( "%s\nDownloading... %s/%s - %.1f%% done" ),
-                      p_update->release.psz_url, psz_downloaded, psz_size,
-                      f_progress*100 ) != -1 )
-        {
-            dialog_ProgressSet( p_progress, psz_status, f_progress );
-            free( psz_status );
-        }
+        vlc_dialog_update_progress_text( p_udt, i_dialog_id, f_pos,
+                                         "%s\nDownloading... %s/%s - %.1f%% done",
+                                         p_update->release.psz_url,
+                                         psz_downloaded, psz_size,
+                                         f_progress*100 );
         free( psz_downloaded );
     }
 
@@ -629,10 +632,10 @@ static void* update_DownloadReal( void *obj )
     p_file = NULL;
 
     if( !atomic_load( &p_udt->aborted ) &&
-        !dialog_ProgressCancelled( p_progress ) )
+        !vlc_dialog_cancelled( p_udt, i_dialog_id ) )
     {
-        dialog_ProgressDestroy( p_progress );
-        p_progress = NULL;
+        vlc_dialog_cancel( p_udt, i_dialog_id );
+        i_dialog_id = 0;
     }
     else
     {
@@ -719,10 +722,13 @@ static void* update_DownloadReal( void *obj )
     free( p_hash );
 
 #ifdef _WIN32
-    int answer = dialog_Question( p_udt, _("Update VLC media player"),
-    _("The new version was successfully downloaded. Do you want to close VLC and install it now?"),
-    _("Install"), _("Cancel"), NULL);
-
+    static const char *psz_msg =
+        _("The new version was successfully downloaded."
+        "Do you want to close VLC and install it now?");
+    int answer = vlc_dialog_wait_question( p_udt, VLC_DIALOG_QUESTION_NORMAL,
+                                           _("Cancel"), _("Install"), NULL,
+                                           _("Update VLC media player"),
+                                           psz_msg );
     if(answer == 1)
     {
         wchar_t psz_wdestfile[MAX_PATH];
@@ -733,8 +739,8 @@ static void* update_DownloadReal( void *obj )
     }
 #endif
 end:
-    if( p_progress )
-        dialog_ProgressDestroy( p_progress );
+    if( i_dialog_id != 0 )
+        vlc_dialog_cancel( p_udt, i_dialog_id );
     if( p_stream )
         stream_Delete( p_stream );
     if( p_file )
diff --git a/test/modules/misc/tls.c b/test/modules/misc/tls.c
index d7f4a2c..8e9030e 100644
--- a/test/modules/misc/tls.c
+++ b/test/modules/misc/tls.c
@@ -47,18 +47,20 @@ static int tlspair(int fds[2])
     return vlc_socketpair(PF_LOCAL, SOCK_STREAM, 0, fds, true);
 }
 
-static int question_callback(vlc_object_t *obj, const char *varname,
-                             vlc_value_t old, vlc_value_t cur, void *data)
+static bool dialog_display_cb(vlc_dialog_id *p_id, vlc_dialog *dialog, void *data)
 {
-    dialog_question_t *q = cur.p_address;
+    if (dialog->i_type != VLC_DIALOG_QUESTION)
+        return false;
     int *value = data;
+    vlc_dialog_id_post_action(p_id, *value);
+    return true;
+}
 
-    q->answer = *value;
-
-    assert(obj == VLC_OBJECT(obj->p_libvlc));
-    assert(!strcmp(varname, "dialog-question"));
-    (void) old;
-    return VLC_SUCCESS;
+static bool dialog_cancel_cb(vlc_dialog_id *p_id, void *data)
+{
+    (void)p_id;
+    (void)data;
+    return true;
 }
 
 static libvlc_instance_t *vlc;
@@ -172,9 +174,12 @@ int main(void)
     client_creds = vlc_tls_ClientCreate(obj);
     assert(client_creds != NULL);
 
-    var_Create(obj, "dialog-question", VLC_VAR_ADDRESS);
-    var_AddCallback(obj, "dialog-question", question_callback, &answer);
-    dialog_Register(obj);
+    vlc_dialog_cbs cbs = {
+        dialog_display_cb,
+        dialog_cancel_cb,
+        NULL,
+    };
+    vlc_dialog_provider_set_callbacks(obj, &cbs, &answer);
 
     vlc_thread_t th;
     vlc_tls_t *tls;
@@ -188,7 +193,7 @@ int main(void)
     assert(val == -1);
 
     /* Accept unknown certificate */
-    answer = 2;
+    answer = 1;
     val = securepair(&th, &tls, alpnv, &alp);
     assert(val == 0);
     assert(alp != NULL);
@@ -269,8 +274,7 @@ int main(void)
     vlc_tls_Close(tls);
     vlc_join(th, NULL);
 
-    dialog_Unregister(obj);
-    var_DelCallback(obj, "dialog-question", question_callback, &answer);
+    vlc_dialog_provider_set_callbacks(obj, NULL, NULL);
     vlc_tls_Delete(client_creds);
     vlc_tls_Delete(server_creds);
     libvlc_release(vlc);
-- 
2.7.0.rc3



More information about the vlc-devel mailing list