src/gtk1/dialog.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        dialog.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "dialog.h"
#endif

#include "wx/dialog.h"
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/cursor.h"

#include <gdk/gdk.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include "wx/gtk/win_gtk.h"

//-----------------------------------------------------------------------------
// idle system
//-----------------------------------------------------------------------------

extern void wxapp_install_idle_handler();
extern bool g_isIdle;
extern int g_openDialogs;

//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------

extern wxList wxPendingDelete;

//-----------------------------------------------------------------------------
// "focus" from m_window
//-----------------------------------------------------------------------------

static gint gtk_dialog_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    // This disables GTK's tab traversal
    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
    return TRUE;
}

//-----------------------------------------------------------------------------
// "delete_event"
//-----------------------------------------------------------------------------

bool gtk_dialog_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxDialog *win )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    if (win->IsEnabled())
        win->Close();

    return TRUE;
}

//-----------------------------------------------------------------------------
// "size_allocate"
//-----------------------------------------------------------------------------

static void gtk_dialog_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxDialog *win )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    if (!win->m_hasVMT) return;

    if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
    {
        win->m_width = alloc->width;
        win->m_height = alloc->height;
        win->GtkUpdateSize();
    }
}

//-----------------------------------------------------------------------------
// "configure_event"
//-----------------------------------------------------------------------------

static gint
#if (GTK_MINOR_VERSION > 0)
gtk_dialog_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxDialog *win )
#else
gtk_dialog_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxDialog *win )
#endif
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    if (!win->m_hasVMT) return FALSE;

#if (GTK_MINOR_VERSION > 0)
    int x = 0;
    int y = 0;
    gdk_window_get_root_origin( win->m_widget->window, &x, &y );
    win->m_x = x;
    win->m_y = y;
#else
    win->m_x = event->x;
    win->m_y = event->y;
#endif

    wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
    mevent.SetEventObject( win );
    win->GetEventHandler()->ProcessEvent( mevent );

    return FALSE;
}

//-----------------------------------------------------------------------------
// "realize" from m_widget
//-----------------------------------------------------------------------------

/* we cannot MWM hints and icons before the widget has been realized,
   so we do this directly after realization */

static gint
gtk_dialog_realized_callback( GtkWidget * WXUNUSED(widget), wxDialog *win )
{
    if (g_isIdle)
        wxapp_install_idle_handler();

    /* all this is for Motif Window Manager "hints" and is supposed to be
       recognized by other WM as well. not tested. */
    long decor = (long) GDK_DECOR_BORDER;
    long func = (long) GDK_FUNC_MOVE ;

    /* Some WM don't display any border around the frame contents if
       used with these hints, so we add a resize border around it,
       without automatically allowinng it to be resized though.

       This avoids the problem, but looks odd. What shall we do?
    */
    decor |= GDK_DECOR_RESIZEH;

    if ((win->GetWindowStyle() & wxCAPTION) != 0)
        decor |= GDK_DECOR_TITLE;
    if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
    {
       decor |= GDK_DECOR_MENU;
       func |= GDK_FUNC_CLOSE;
    }
    if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
    {
        func |= GDK_FUNC_MINIMIZE;
        decor |= GDK_DECOR_MINIMIZE;
    }
    if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
    {
        decor |= GDK_DECOR_MAXIMIZE;
        func |= GDK_FUNC_MAXIMIZE;
    }
    if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
    {
       func |= GDK_FUNC_RESIZE;
       decor |= GDK_DECOR_RESIZEH;
    }
    gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
    gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);

    /* GTK's shrinking/growing policy */
    if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
    else
        gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);

    /* reset the icon */
    if (win->m_icon != wxNullIcon)
    {
        wxIcon icon( win->m_icon );
        win->m_icon = wxNullIcon;
        win->SetIcon( icon );
    }

    return FALSE;
}

//-----------------------------------------------------------------------------
// InsertChild for wxDialog
//-----------------------------------------------------------------------------

/* Callback for wxFrame. This very strange beast has to be used because
 * C++ has no virtual methods in a constructor. We have to emulate a
 * virtual function here as wxWindows requires different ways to insert
 * a child in container classes. */

static void wxInsertChildInDialog( wxDialog* parent, wxWindow* child )
{
    gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
                     GTK_WIDGET(child->m_widget),
                     child->m_x,
                     child->m_y,
                     child->m_width,
                     child->m_height );

    if (parent->HasFlag(wxTAB_TRAVERSAL))
    {
        /* we now allow a window to get the focus as long as it
           doesn't have any children. */
        GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
    }
}

//-----------------------------------------------------------------------------
// wxDialog
//-----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxDialog,wxPanel)
    EVT_BUTTON  (wxID_OK,       wxDialog::OnOK)
    EVT_BUTTON  (wxID_CANCEL,   wxDialog::OnCancel)
    EVT_BUTTON  (wxID_APPLY,    wxDialog::OnApply)
    EVT_SIZE    (wxDialog::OnSize)
    EVT_CLOSE   (wxDialog::OnCloseWindow)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxPanel)

void wxDialog::Init()
{
    m_returnCode = 0;
    m_sizeSet = FALSE;
    m_modalShowing = FALSE;
    m_themeEnabled = TRUE;
}

wxDialog::wxDialog( wxWindow *parent,
                    wxWindowID id, const wxString &title,
                    const wxPoint &pos, const wxSize &size,
                    long style, const wxString &name )
{
    Init();

    Create( parent, id, title, pos, size, style, name );
}

bool wxDialog::Create( wxWindow *parent,
                       wxWindowID id, const wxString &title,
                       const wxPoint &pos, const wxSize &size,
                       long style, const wxString &name )
{
    wxTopLevelWindows.Append( this );

    m_needParent = FALSE;

    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
    {
        wxFAIL_MSG( wxT("wxDialog creation failed") );
        return FALSE;
    }

    // All dialogs should really have this style
    m_windowStyle |= wxTAB_TRAVERSAL;

    m_insertCallback = (wxInsertChildFunction) wxInsertChildInDialog;

    m_widget = gtk_window_new( GTK_WINDOW_DIALOG );

    if ((m_parent) && (GTK_IS_WINDOW(m_parent->m_widget)))
        gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );

    if (!name.IsEmpty())
        gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );

    GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );

    gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
        GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );

    m_wxwindow = gtk_pizza_new();
    gtk_widget_show( m_wxwindow );
    GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

    gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );

    SetTitle( title );

    if (m_parent) m_parent->AddChild( this );

    PostCreation();

    if ((m_x != -1) || (m_y != -1))
        gtk_widget_set_uposition( m_widget, m_x, m_y );
    gtk_widget_set_usize( m_widget, m_width, m_height );

    /*  we cannot set MWM hints  before the widget has
        been realized, so we do this directly after realization */
    gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
                        GTK_SIGNAL_FUNC(gtk_dialog_realized_callback), (gpointer) this );

    /* the user resized the frame by dragging etc. */
    gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
        GTK_SIGNAL_FUNC(gtk_dialog_size_callback), (gpointer)this );

    gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
        GTK_SIGNAL_FUNC(gtk_dialog_configure_callback), (gpointer)this );

    /* disable native tab traversal */
    gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
        GTK_SIGNAL_FUNC(gtk_dialog_focus_callback), (gpointer)this );

    return TRUE;
}

wxDialog::~wxDialog()
{
    CleanUp();

    if ((wxTopLevelWindows.Number() == 0) &&
        (wxTheApp->GetExitOnFrameDelete()))
    {
        wxTheApp->ExitMainLoop();
    }
}

void wxDialog::SetTitle( const wxString& title )
{
    m_title = title;
    gtk_window_set_title( GTK_WINDOW(m_widget), m_title.mbc_str() );
}

wxString wxDialog::GetTitle() const
{
    return m_title;
}

void wxDialog::OnApply( wxCommandEvent &WXUNUSED(event) )
{
    if (Validate()) TransferDataFromWindow();
}

void wxDialog::OnCancel( wxCommandEvent &WXUNUSED(event) )
{
    if (IsModal())
    {
        EndModal(wxID_CANCEL);
    }
    else
    {
        SetReturnCode(wxID_CANCEL);
        Show(FALSE);
    }
}

void wxDialog::OnOK( wxCommandEvent &WXUNUSED(event) )
{
    if (Validate() && TransferDataFromWindow())
    {
        if (IsModal())
        {
            EndModal(wxID_OK);
        }
        else
        {
            SetReturnCode(wxID_OK);
            Show(FALSE);
        }
    }
}

void wxDialog::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
    // yes
}

void wxDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
{
    // We'll send a Cancel message by default,
    // which may close the dialog.
    // Check for looping if the Cancel event handler calls Close().

    // Note that if a cancel button and handler aren't present in the dialog,
    // nothing will happen when you close the dialog via the window manager, or
    // via Close().
    // We wouldn't want to destroy the dialog by default, since the dialog may have been
    // created on the stack.
    // However, this does mean that calling dialog->Close() won't delete the dialog
    // unless the handler for wxID_CANCEL does so. So use Destroy() if you want to be
    // sure to destroy the dialog.
    // The default OnCancel (above) simply ends a modal dialog, and hides a modeless dialog.

    static wxList s_closing;

    if (s_closing.Member(this))
        return;   // no loops

    s_closing.Append(this);

    wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
    cancelEvent.SetEventObject( this );
    GetEventHandler()->ProcessEvent(cancelEvent);
    s_closing.DeleteObject(this);
}

bool wxDialog::Destroy()
{
    // schedule the dialog for the deletion
    if ( !wxPendingDelete.Member(this) )
    {
        wxPendingDelete.Append(this);
    }

    // don't leave a dangling pointer as the app top window, we can be deleted
    // any moment at all now!
    CleanUp();

    return TRUE;
}

void wxDialog::CleanUp()
{
    m_isBeingDeleted = TRUE;

    if ( wxTheApp->GetTopWindow() == this )
    {
        wxTheApp->SetTopWindow( (wxWindow*) NULL );
    }

    wxTopLevelWindows.DeleteObject( this );
}

void wxDialog::OnSize( wxSizeEvent &WXUNUSED(event) )
{
    wxASSERT_MSG( (m_widget != NULL), wxT("invalid dialog") );

#if wxUSE_CONSTRAINTS
    if (GetAutoLayout())
    {
        Layout();
    }
    else
#endif // wxUSE_CONSTRAINTS
    {
        /* no child: go out ! */
        if (!GetChildren().First()) return;

        /* do we have exactly one child? */
        wxWindow *child = (wxWindow *) NULL;
        for(wxNode *node = GetChildren().First(); node; node = node->Next())
        {
            wxWindow *win = (wxWindow *)node->Data();
            if (!wxIS_KIND_OF(win,wxFrame) && !wxIS_KIND_OF(win,wxDialog))
            {
                /* it's the second one: do nothing */
                if (child) return;
                child = win;
            }
        }

        /* yes: set it's size to fill all the frame */
        int client_x, client_y;
        GetClientSize( &client_x, &client_y );
        child->SetSize( 1, 1, client_x-2, client_y);
    }
}

void wxDialog::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
{
    wxFAIL_MSG( wxT("DoMoveWindow called for wxDialog") );
}

void wxDialog::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{
    wxASSERT_MSG( (m_widget != NULL), wxT("invalid dialog") );
    wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid dialog") );

    if (m_resizing) return; /* I don't like recursions */
    m_resizing = TRUE;

    int old_x = m_x;
    int old_y = m_y;

    int old_width = m_width;
    int old_height = m_height;

    if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
    {
        if (x != -1) m_x = x;
        if (y != -1) m_y = y;
        if (width != -1) m_width = width;
        if (height != -1) m_height = height;
    }
    else
    {
        m_x = x;
        m_y = y;
        m_width = width;
        m_height = height;
    }

/*
    if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
    {
        if (width == -1) m_width = 80;
    }

    if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
    {
       if (height == -1) m_height = 26;
    }
*/

    if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
    if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
    if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
    if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;

    if ((m_x != -1) || (m_y != -1))
    {
        if ((m_x != old_x) || (m_y != old_y))
        {
            /* we set the position here and when showing the dialog
               for the first time in idle time */
            gtk_widget_set_uposition( m_widget, m_x, m_y );
        }
    }

    if ((m_width != old_width) || (m_height != old_height))
    {
        gtk_widget_set_usize( m_widget, m_width, m_height );

        /* actual resizing is deferred to GtkOnSize in idle time and
           when showing the dialog */
        m_sizeSet = FALSE;
    }

    m_resizing = FALSE;
}

void wxDialog::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
{
    // due to a bug in gtk, x,y are always 0
    // m_x = x;
    // m_y = y;

    if ((m_height == height) && (m_width == width) && (m_sizeSet)) return;
    if (!m_wxwindow) return;

    m_width = width;
    m_height = height;

    if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
    if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
    if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
    if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;

    /* set size hints */
    gint flag = 0; // GDK_HINT_POS;
    if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
    if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
    GdkGeometry geom;
    geom.min_width = m_minWidth;
    geom.min_height = m_minHeight;
    geom.max_width = m_maxWidth;
    geom.max_height = m_maxHeight;
    gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
                                   (GtkWidget*) NULL,
                                   &geom,
                                   (GdkWindowHints) flag );

    m_sizeSet = TRUE;

    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
    event.SetEventObject( this );
    GetEventHandler()->ProcessEvent( event );
}

void wxDialog::OnInternalIdle()
{
    if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
        GtkOnSize( m_x, m_y, m_width, m_height );

    wxWindow::OnInternalIdle();
}

bool wxDialog::Show( bool show )
{
    if (!show && IsModal())
    {
        EndModal( wxID_CANCEL );
    }

    if (show && !m_sizeSet)
    {
        /* by calling GtkOnSize here, we don't have to call
           either after showing the frame, which would entail
           much ugly flicker nor from within the size_allocate
           handler, because GTK 1.1.X forbids that. */

        GtkOnSize( m_x, m_y, m_width, m_height );
    }

    bool ret = wxWindow::Show( show );

    if (show) InitDialog();

    return ret;
}

bool wxDialog::IsModal() const
{
    return m_modalShowing;
}

void wxDialog::SetModal( bool WXUNUSED(flag) )
{
/*
  if (flag)
    m_windowStyle |= wxDIALOG_MODAL;
  else
    if (m_windowStyle & wxDIALOG_MODAL) m_windowStyle -= wxDIALOG_MODAL;
*/
    wxFAIL_MSG( wxT("wxDialog:SetModal obsolete now") );
}

int wxDialog::ShowModal()
{
    if (IsModal())
    {
       wxFAIL_MSG( wxT("wxDialog:ShowModal called twice") );
       return GetReturnCode();
    }

    // use the apps top level window as parent if none given unless explicitly
    // forbidden
    if ( !GetParent() && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT) )
    {
        wxWindow *parent = wxTheApp->GetTopWindow();
        if ( parent && parent != this )
        {
            m_parent = parent;
            gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(parent->m_widget) );
        }
    }

    wxBusyCursorSuspender cs; // temporarily suppress the busy cursor

    Show( TRUE );

    m_modalShowing = TRUE;

    g_openDialogs++;

    gtk_grab_add( m_widget );
    gtk_main();
    gtk_grab_remove( m_widget );

    g_openDialogs--;

    return GetReturnCode();
}

void wxDialog::EndModal( int retCode )
{
    SetReturnCode( retCode );

    if (!IsModal())
    {
        wxFAIL_MSG( wxT("wxDialog:EndModal called twice") );
        return;
    }

    m_modalShowing = FALSE;

    gtk_main_quit();

    Show( FALSE );
}

void wxDialog::InitDialog()
{
    wxWindow::InitDialog();
}

void wxDialog::SetIcon( const wxIcon &icon )
{
    m_icon = icon;
    if (!icon.Ok()) return;

    if (!m_widget->window) return;

    wxMask *mask = icon.GetMask();
    GdkBitmap *bm = (GdkBitmap *) NULL;
    if (mask) bm = mask->GetBitmap();

    gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: dialog.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#ifdef __GNUG__
	11	#pragma implementation "dialog.h"
	12	#endif
	13
	14	#include "wx/dialog.h"
	15	#include "wx/frame.h"
	16	#include "wx/app.h"
	17	#include "wx/cursor.h"
	18
	19	#include <gdk/gdk.h>
	20	#include <gtk/gtk.h>
	21	#include <gdk/gdkkeysyms.h>
	22
	23	#include "wx/gtk/win_gtk.h"
	24
	25	//-----------------------------------------------------------------------------
	26	// idle system
	27	//-----------------------------------------------------------------------------
	28
	29	extern void wxapp_install_idle_handler();
	30	extern bool g_isIdle;
	31	extern int g_openDialogs;
	32
	33	//-----------------------------------------------------------------------------
	34	// data
	35	//-----------------------------------------------------------------------------
	36
	37	extern wxList wxPendingDelete;
	38
	39	//-----------------------------------------------------------------------------
	40	// "focus" from m_window
	41	//-----------------------------------------------------------------------------
	42
	43	static gint gtk_dialog_focus_callback( GtkWidget widget, GtkDirectionType WXUNUSED(d), wxWindow WXUNUSED(win) )
	44	{
	45	if (g_isIdle)
	46	wxapp_install_idle_handler();
	47
	48	// This disables GTK's tab traversal
	49	gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
	50	return TRUE;
	51	}
	52
	53	//-----------------------------------------------------------------------------
	54	// "delete_event"
	55	//-----------------------------------------------------------------------------
	56
	57	bool gtk_dialog_delete_callback( GtkWidget WXUNUSED(widget), GdkEvent WXUNUSED(event), wxDialog *win )
	58	{
	59	if (g_isIdle)
	60	wxapp_install_idle_handler();
	61
	62	if (win->IsEnabled())
	63	win->Close();
	64
	65	return TRUE;
	66	}
	67
	68	//-----------------------------------------------------------------------------
	69	// "size_allocate"
	70	//-----------------------------------------------------------------------------
	71
	72	static void gtk_dialog_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxDialog *win )
	73	{
	74	if (g_isIdle)
	75	wxapp_install_idle_handler();
	76
	77	if (!win->m_hasVMT) return;
	78
	79	if ((win->m_width != alloc->width) \|\| (win->m_height != alloc->height))
	80	{
	81	win->m_width = alloc->width;
	82	win->m_height = alloc->height;
	83	win->GtkUpdateSize();
	84	}
	85	}
	86
	87	//-----------------------------------------------------------------------------
	88	// "configure_event"
	89	//-----------------------------------------------------------------------------
	90
	91	static gint
	92	#if (GTK_MINOR_VERSION > 0)
	93	gtk_dialog_configure_callback( GtkWidget WXUNUSED(widget), GdkEventConfigure WXUNUSED(event), wxDialog *win )
	94	#else
	95	gtk_dialog_configure_callback( GtkWidget WXUNUSED(widget), GdkEventConfigure event, wxDialog *win )
	96	#endif
	97	{
	98	if (g_isIdle)
	99	wxapp_install_idle_handler();
	100
	101	if (!win->m_hasVMT) return FALSE;
	102
	103	#if (GTK_MINOR_VERSION > 0)
	104	int x = 0;
	105	int y = 0;
	106	gdk_window_get_root_origin( win->m_widget->window, &x, &y );
	107	win->m_x = x;
	108	win->m_y = y;
	109	#else
	110	win->m_x = event->x;
	111	win->m_y = event->y;
	112	#endif
	113
	114	wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
	115	mevent.SetEventObject( win );
	116	win->GetEventHandler()->ProcessEvent( mevent );
	117
	118	return FALSE;
	119	}
	120
	121	//-----------------------------------------------------------------------------
	122	// "realize" from m_widget
	123	//-----------------------------------------------------------------------------
	124
	125	/* we cannot MWM hints and icons before the widget has been realized,
	126	so we do this directly after realization */
	127
	128	static gint
	129	gtk_dialog_realized_callback( GtkWidget * WXUNUSED(widget), wxDialog *win )
	130	{
	131	if (g_isIdle)
	132	wxapp_install_idle_handler();
	133
	134	/* all this is for Motif Window Manager "hints" and is supposed to be
	135	recognized by other WM as well. not tested. */
	136	long decor = (long) GDK_DECOR_BORDER;
	137	long func = (long) GDK_FUNC_MOVE ;
	138
	139	/* Some WM don't display any border around the frame contents if
	140	used with these hints, so we add a resize border around it,
	141	without automatically allowinng it to be resized though.
	142
	143	This avoids the problem, but looks odd. What shall we do?
	144	*/
	145	decor \|= GDK_DECOR_RESIZEH;
	146
	147	if ((win->GetWindowStyle() & wxCAPTION) != 0)
	148	decor \|= GDK_DECOR_TITLE;
	149	if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
	150	{
	151	decor \|= GDK_DECOR_MENU;
	152	func \|= GDK_FUNC_CLOSE;
	153	}
	154	if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
	155	{
	156	func \|= GDK_FUNC_MINIMIZE;
	157	decor \|= GDK_DECOR_MINIMIZE;
	158	}
	159	if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
	160	{
	161	decor \|= GDK_DECOR_MAXIMIZE;
	162	func \|= GDK_FUNC_MAXIMIZE;
	163	}
	164	if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
	165	{
	166	func \|= GDK_FUNC_RESIZE;
	167	decor \|= GDK_DECOR_RESIZEH;
	168	}
	169	gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
	170	gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
	171
	172	/* GTK's shrinking/growing policy */
	173	if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
	174	gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
	175	else
	176	gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
	177
	178	/* reset the icon */
	179	if (win->m_icon != wxNullIcon)
	180	{
	181	wxIcon icon( win->m_icon );
	182	win->m_icon = wxNullIcon;
	183	win->SetIcon( icon );
	184	}
	185
	186	return FALSE;
	187	}
	188
	189	//-----------------------------------------------------------------------------
	190	// InsertChild for wxDialog
	191	//-----------------------------------------------------------------------------
	192
	193	/* Callback for wxFrame. This very strange beast has to be used because
	194	* C++ has no virtual methods in a constructor. We have to emulate a
	195	* virtual function here as wxWindows requires different ways to insert
	196	* a child in container classes. */
	197
	198	static void wxInsertChildInDialog( wxDialog* parent, wxWindow* child )
	199	{
	200	gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
	201	GTK_WIDGET(child->m_widget),
	202	child->m_x,
	203	child->m_y,
	204	child->m_width,
	205	child->m_height );
	206
	207	if (parent->HasFlag(wxTAB_TRAVERSAL))
	208	{
	209	/* we now allow a window to get the focus as long as it
	210	doesn't have any children. */
	211	GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
	212	}
	213	}
	214
	215	//-----------------------------------------------------------------------------
	216	// wxDialog
	217	//-----------------------------------------------------------------------------
	218
	219	BEGIN_EVENT_TABLE(wxDialog,wxPanel)
	220	EVT_BUTTON (wxID_OK, wxDialog::OnOK)
	221	EVT_BUTTON (wxID_CANCEL, wxDialog::OnCancel)
	222	EVT_BUTTON (wxID_APPLY, wxDialog::OnApply)
	223	EVT_SIZE (wxDialog::OnSize)
	224	EVT_CLOSE (wxDialog::OnCloseWindow)
	225	END_EVENT_TABLE()
	226
	227	IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxPanel)
	228
	229	void wxDialog::Init()
	230	{
	231	m_returnCode = 0;
	232	m_sizeSet = FALSE;
	233	m_modalShowing = FALSE;
	234	m_themeEnabled = TRUE;
	235	}
	236
	237	wxDialog::wxDialog( wxWindow *parent,
	238	wxWindowID id, const wxString &title,
	239	const wxPoint &pos, const wxSize &size,
	240	long style, const wxString &name )
	241	{
	242	Init();
	243
	244	Create( parent, id, title, pos, size, style, name );
	245	}
	246
	247	bool wxDialog::Create( wxWindow *parent,
	248	wxWindowID id, const wxString &title,
	249	const wxPoint &pos, const wxSize &size,
	250	long style, const wxString &name )
	251	{
	252	wxTopLevelWindows.Append( this );
	253
	254	m_needParent = FALSE;
	255
	256	if (!PreCreation( parent, pos, size ) \|\|
	257	!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
	258	{
	259	wxFAIL_MSG( wxT("wxDialog creation failed") );
	260	return FALSE;
	261	}
	262
	263	// All dialogs should really have this style
	264	m_windowStyle \|= wxTAB_TRAVERSAL;
	265
	266	m_insertCallback = (wxInsertChildFunction) wxInsertChildInDialog;
	267
	268	m_widget = gtk_window_new( GTK_WINDOW_DIALOG );
	269
	270	if ((m_parent) && (GTK_IS_WINDOW(m_parent->m_widget)))
	271	gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
	272
	273	if (!name.IsEmpty())
	274	gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
	275
	276	GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
	277
	278	gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
	279	GTK_SIGNAL_FUNC(gtk_dialog_delete_callback), (gpointer)this );
	280
	281	m_wxwindow = gtk_pizza_new();
	282	gtk_widget_show( m_wxwindow );
	283	GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
	284
	285	gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
	286
	287	SetTitle( title );
	288
	289	if (m_parent) m_parent->AddChild( this );
	290
	291	PostCreation();
	292
	293	if ((m_x != -1) \|\| (m_y != -1))
	294	gtk_widget_set_uposition( m_widget, m_x, m_y );
	295	gtk_widget_set_usize( m_widget, m_width, m_height );
	296
	297	/* we cannot set MWM hints before the widget has
	298	been realized, so we do this directly after realization */
	299	gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
	300	GTK_SIGNAL_FUNC(gtk_dialog_realized_callback), (gpointer) this );
	301
	302	/* the user resized the frame by dragging etc. */
	303	gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
	304	GTK_SIGNAL_FUNC(gtk_dialog_size_callback), (gpointer)this );
	305
	306	gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
	307	GTK_SIGNAL_FUNC(gtk_dialog_configure_callback), (gpointer)this );
	308
	309	/* disable native tab traversal */
	310	gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
	311	GTK_SIGNAL_FUNC(gtk_dialog_focus_callback), (gpointer)this );
	312
	313	return TRUE;
	314	}
	315
	316	wxDialog::~wxDialog()
	317	{
	318	CleanUp();
	319
	320	if ((wxTopLevelWindows.Number() == 0) &&
	321	(wxTheApp->GetExitOnFrameDelete()))
	322	{
	323	wxTheApp->ExitMainLoop();
	324	}
	325	}
	326
	327	void wxDialog::SetTitle( const wxString& title )
	328	{
	329	m_title = title;
	330	gtk_window_set_title( GTK_WINDOW(m_widget), m_title.mbc_str() );
	331	}
	332
	333	wxString wxDialog::GetTitle() const
	334	{
	335	return m_title;
	336	}
	337
	338	void wxDialog::OnApply( wxCommandEvent &WXUNUSED(event) )
	339	{
	340	if (Validate()) TransferDataFromWindow();
	341	}
	342
	343	void wxDialog::OnCancel( wxCommandEvent &WXUNUSED(event) )
	344	{
	345	if (IsModal())
	346	{
	347	EndModal(wxID_CANCEL);
	348	}
	349	else
	350	{
	351	SetReturnCode(wxID_CANCEL);
	352	Show(FALSE);
	353	}
	354	}
	355
	356	void wxDialog::OnOK( wxCommandEvent &WXUNUSED(event) )
	357	{
	358	if (Validate() && TransferDataFromWindow())
	359	{
	360	if (IsModal())
	361	{
	362	EndModal(wxID_OK);
	363	}
	364	else
	365	{
	366	SetReturnCode(wxID_OK);
	367	Show(FALSE);
	368	}
	369	}
	370	}
	371
	372	void wxDialog::OnPaint( wxPaintEvent& WXUNUSED(event) )
	373	{
	374	// yes
	375	}
	376
	377	void wxDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
	378	{
	379	// We'll send a Cancel message by default,
	380	// which may close the dialog.
	381	// Check for looping if the Cancel event handler calls Close().
	382
	383	// Note that if a cancel button and handler aren't present in the dialog,
	384	// nothing will happen when you close the dialog via the window manager, or
	385	// via Close().
	386	// We wouldn't want to destroy the dialog by default, since the dialog may have been
	387	// created on the stack.
	388	// However, this does mean that calling dialog->Close() won't delete the dialog
	389	// unless the handler for wxID_CANCEL does so. So use Destroy() if you want to be
	390	// sure to destroy the dialog.
	391	// The default OnCancel (above) simply ends a modal dialog, and hides a modeless dialog.
	392
	393	static wxList s_closing;
	394
	395	if (s_closing.Member(this))
	396	return; // no loops
	397
	398	s_closing.Append(this);
	399
	400	wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
	401	cancelEvent.SetEventObject( this );
	402	GetEventHandler()->ProcessEvent(cancelEvent);
	403	s_closing.DeleteObject(this);
	404	}
	405
	406	bool wxDialog::Destroy()
	407	{
	408	// schedule the dialog for the deletion
	409	if ( !wxPendingDelete.Member(this) )
	410	{
	411	wxPendingDelete.Append(this);
	412	}
	413
	414	// don't leave a dangling pointer as the app top window, we can be deleted
	415	// any moment at all now!
	416	CleanUp();
	417
	418	return TRUE;
	419	}
	420
	421	void wxDialog::CleanUp()
	422	{
	423	m_isBeingDeleted = TRUE;
	424
	425	if ( wxTheApp->GetTopWindow() == this )
	426	{
	427	wxTheApp->SetTopWindow( (wxWindow*) NULL );
	428	}
	429
	430	wxTopLevelWindows.DeleteObject( this );
	431	}
	432
	433	void wxDialog::OnSize( wxSizeEvent &WXUNUSED(event) )
	434	{
	435	wxASSERT_MSG( (m_widget != NULL), wxT("invalid dialog") );
	436
	437	#if wxUSE_CONSTRAINTS
	438	if (GetAutoLayout())
	439	{
	440	Layout();
	441	}
	442	else
	443	#endif // wxUSE_CONSTRAINTS
	444	{
	445	/* no child: go out ! */
	446	if (!GetChildren().First()) return;
	447
	448	/* do we have exactly one child? */
	449	wxWindow child = (wxWindow ) NULL;
	450	for(wxNode *node = GetChildren().First(); node; node = node->Next())
	451	{
	452	wxWindow win = (wxWindow )node->Data();
	453	if (!wxIS_KIND_OF(win,wxFrame) && !wxIS_KIND_OF(win,wxDialog))
	454	{
	455	/* it's the second one: do nothing */
	456	if (child) return;
	457	child = win;
	458	}
	459	}
	460
	461	/* yes: set it's size to fill all the frame */
	462	int client_x, client_y;
	463	GetClientSize( &client_x, &client_y );
	464	child->SetSize( 1, 1, client_x-2, client_y);
	465	}
	466	}
	467
	468	void wxDialog::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
	469	{
	470	wxFAIL_MSG( wxT("DoMoveWindow called for wxDialog") );
	471	}
	472
	473	void wxDialog::DoSetSize( int x, int y, int width, int height, int sizeFlags )
	474	{
	475	wxASSERT_MSG( (m_widget != NULL), wxT("invalid dialog") );
	476	wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid dialog") );
	477
	478	if (m_resizing) return; /* I don't like recursions */
	479	m_resizing = TRUE;
	480
	481	int old_x = m_x;
	482	int old_y = m_y;
	483
	484	int old_width = m_width;
	485	int old_height = m_height;
	486
	487	if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
	488	{
	489	if (x != -1) m_x = x;
	490	if (y != -1) m_y = y;
	491	if (width != -1) m_width = width;
	492	if (height != -1) m_height = height;
	493	}
	494	else
	495	{
	496	m_x = x;
	497	m_y = y;
	498	m_width = width;
	499	m_height = height;
	500	}
	501
	502	/*
	503	if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
	504	{
	505	if (width == -1) m_width = 80;
	506	}
	507
	508	if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
	509	{
	510	if (height == -1) m_height = 26;
	511	}
	512	*/
	513
	514	if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
	515	if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
	516	if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
	517	if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
	518
	519	if ((m_x != -1) \|\| (m_y != -1))
	520	{
	521	if ((m_x != old_x) \|\| (m_y != old_y))
	522	{
	523	/* we set the position here and when showing the dialog
	524	for the first time in idle time */
	525	gtk_widget_set_uposition( m_widget, m_x, m_y );
	526	}
	527	}
	528
	529	if ((m_width != old_width) \|\| (m_height != old_height))
	530	{
	531	gtk_widget_set_usize( m_widget, m_width, m_height );
	532
	533	/* actual resizing is deferred to GtkOnSize in idle time and
	534	when showing the dialog */
	535	m_sizeSet = FALSE;
	536	}
	537
	538	m_resizing = FALSE;
	539	}
	540
	541	void wxDialog::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
	542	{
	543	// due to a bug in gtk, x,y are always 0
	544	// m_x = x;
	545	// m_y = y;
	546
	547	if ((m_height == height) && (m_width == width) && (m_sizeSet)) return;
	548	if (!m_wxwindow) return;
	549
	550	m_width = width;
	551	m_height = height;
	552
	553	if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
	554	if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
	555	if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
	556	if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
	557
	558	/* set size hints */
	559	gint flag = 0; // GDK_HINT_POS;
	560	if ((m_minWidth != -1) \|\| (m_minHeight != -1)) flag \|= GDK_HINT_MIN_SIZE;
	561	if ((m_maxWidth != -1) \|\| (m_maxHeight != -1)) flag \|= GDK_HINT_MAX_SIZE;
	562	GdkGeometry geom;
	563	geom.min_width = m_minWidth;
	564	geom.min_height = m_minHeight;
	565	geom.max_width = m_maxWidth;
	566	geom.max_height = m_maxHeight;
	567	gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
	568	(GtkWidget*) NULL,
	569	&geom,
	570	(GdkWindowHints) flag );
	571
	572	m_sizeSet = TRUE;
	573
	574	wxSizeEvent event( wxSize(m_width,m_height), GetId() );
	575	event.SetEventObject( this );
	576	GetEventHandler()->ProcessEvent( event );
	577	}
	578
	579	void wxDialog::OnInternalIdle()
	580	{
	581	if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
	582	GtkOnSize( m_x, m_y, m_width, m_height );
	583
	584	wxWindow::OnInternalIdle();
	585	}
	586
	587	bool wxDialog::Show( bool show )
	588	{
	589	if (!show && IsModal())
	590	{
	591	EndModal( wxID_CANCEL );
	592	}
	593
	594	if (show && !m_sizeSet)
	595	{
	596	/* by calling GtkOnSize here, we don't have to call
	597	either after showing the frame, which would entail
	598	much ugly flicker nor from within the size_allocate
	599	handler, because GTK 1.1.X forbids that. */
	600
	601	GtkOnSize( m_x, m_y, m_width, m_height );
	602	}
	603
	604	bool ret = wxWindow::Show( show );
	605
	606	if (show) InitDialog();
	607
	608	return ret;
	609	}
	610
	611	bool wxDialog::IsModal() const
	612	{
	613	return m_modalShowing;
	614	}
	615
	616	void wxDialog::SetModal( bool WXUNUSED(flag) )
	617	{
	618	/*
	619	if (flag)
	620	m_windowStyle \|= wxDIALOG_MODAL;
	621	else
	622	if (m_windowStyle & wxDIALOG_MODAL) m_windowStyle -= wxDIALOG_MODAL;
	623	*/
	624	wxFAIL_MSG( wxT("wxDialog:SetModal obsolete now") );
	625	}
	626
	627	int wxDialog::ShowModal()
	628	{
	629	if (IsModal())
	630	{
	631	wxFAIL_MSG( wxT("wxDialog:ShowModal called twice") );
	632	return GetReturnCode();
	633	}
	634
	635	// use the apps top level window as parent if none given unless explicitly
	636	// forbidden
	637	if ( !GetParent() && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT) )
	638	{
	639	wxWindow *parent = wxTheApp->GetTopWindow();
	640	if ( parent && parent != this )
	641	{
	642	m_parent = parent;
	643	gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(parent->m_widget) );
	644	}
	645	}
	646
	647	wxBusyCursorSuspender cs; // temporarily suppress the busy cursor
	648
	649	Show( TRUE );
	650
	651	m_modalShowing = TRUE;
	652
	653	g_openDialogs++;
	654
	655	gtk_grab_add( m_widget );
	656	gtk_main();
	657	gtk_grab_remove( m_widget );
	658
	659	g_openDialogs--;
	660
	661	return GetReturnCode();
	662	}
	663
	664	void wxDialog::EndModal( int retCode )
	665	{
	666	SetReturnCode( retCode );
	667
	668	if (!IsModal())
	669	{
	670	wxFAIL_MSG( wxT("wxDialog:EndModal called twice") );
	671	return;
	672	}
	673
	674	m_modalShowing = FALSE;
	675
	676	gtk_main_quit();
	677
	678	Show( FALSE );
	679	}
	680
	681	void wxDialog::InitDialog()
	682	{
	683	wxWindow::InitDialog();
	684	}
	685
	686	void wxDialog::SetIcon( const wxIcon &icon )
	687	{
	688	m_icon = icon;
	689	if (!icon.Ok()) return;
	690
	691	if (!m_widget->window) return;
	692
	693	wxMask *mask = icon.GetMask();
	694	GdkBitmap bm = (GdkBitmap ) NULL;
	695	if (mask) bm = mask->GetBitmap();
	696
	697	gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
	698	}