]> git.sesse.net Git - vlc/blob - modules/gui/wxwidgets/dialogs/wizard.cpp
* Remove some unneeded complexity in playlist and directory
[vlc] / modules / gui / wxwidgets / dialogs / wizard.cpp
1 /*****************************************************************************
2  * wizard.cpp : wxWindows plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000-2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: ClĂ©ment Stenac <zorglub@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include "dialogs/wizard.hpp"
28 #include "streamdata.h"
29 #include "dialogs/open.hpp"
30
31 #include <wx/listctrl.h>
32 #include <wx/statline.h>
33 #include <network.h>
34 #include <charset.h>
35
36 class wizHelloPage;
37 class wizInputPage;
38
39 /*****************************************************************************
40  * Define events
41  *****************************************************************************/
42 enum
43 {
44     ActionRadio0_Event, ActionRadio1_Event,
45     MoreInfoStreaming_Event,
46     MoreInfoTranscode_Event,
47
48     Open_Event , Choose_Event ,
49     ListView_Event,
50     InputRadio0_Event, InputRadio1_Event,
51     PartialEnable_Event,
52
53     MethodRadio0_Event, MethodRadio1_Event,
54     MethodRadio2_Event, MethodRadio3_Event,
55
56     EncapRadio0_Event, EncapRadio1_Event,
57     EncapRadio2_Event, EncapRadio3_Event,
58     EncapRadio4_Event, EncapRadio5_Event,
59     EncapRadio6_Event, EncapRadio7_Event,
60     EncapRadio8_Event, EncapRadio9_Event,
61     EncapRadio10_Event, EncapRadio11_Event,
62
63     VideoEnable_Event, VideoCodec_Event,VideoBitrate_Event,
64     AudioEnable_Event, AudioCodec_Event,AudioBitrate_Event,
65
66     SAP_Event,
67
68 };
69
70 #define TEXTWIDTH 55
71 #define ACTION_STREAM 0
72 #define ACTION_TRANSCODE 1
73
74 BEGIN_EVENT_TABLE(WizardDialog, wxWizard)
75 END_EVENT_TABLE()
76
77 /*****************************************************************************
78  * Wizard strings
79  *****************************************************************************/
80
81 #define ERROR_MSG _("Error")
82 #define ITEM_NAME _("Streaming/Transcoding Wizard")
83
84 /* Hello page */
85 #define HELLO_TITLE _("Streaming/Transcoding Wizard")
86 #define HELLO_TEXT _("This wizard helps you to stream, transcode or" \
87                      " save a stream.")
88 #define HELLO_STREAMING _("Stream to network")
89 #define HELLO_STREAMING_DESC _("Use this to stream on a network.")
90 #define HELLO_TRANSCODE _("Transcode/Save to file")
91 #define HELLO_TRANSCODE_DESC _("Use this to re-encode a stream and save it "\
92         "to a file.")
93 #define HELLO_NOTICE _("This wizard only contains a small subset " \
94         "of VLC's streaming and transcoding capabilities. Use the Open "\
95         "and Stream Output dialogs to access all of them.")
96
97 #define MOREINFO_STREAM _("Use this to stream on a network")
98
99 #define MOREINFO_TRANSCODE _("Saves the stream to a file. The stream must " \
100         "be a format that VLC recognizes. If desired, the stream can also " \
101         "be transcoded to another format.\n\nPlease note that VLC is not very" \
102         " suited for file-to-file transcoding. Its transcoding " \
103         "features are more appropriate for saving network streams." )
104
105 /* Input page */
106 #define INPUT_TITLE _("Input")
107 #define INPUT_TEXT _("Input stream")
108
109 #define INPUT_OPEN _("Select a stream" )
110 #define INPUT_PL _( "Existing playlist item" )
111
112 #define CHOOSE_STREAM _("You must choose a stream")
113 #define NO_PLAYLIST _("Unable to find playlist")
114
115 #define PARTIAL _("Use this to read only a part of the stream. " \
116                   "To use, enter the starting and ending times (in seconds)." \
117                   "\n\nNote: You must be able to control the incoming stream " \
118                   "(for example, a file or a disc, but not a RTP/UDP " \
119                   "network stream).\n" \
120 )
121
122 #define INPUT_BUTTON _("Choose")
123
124 /* Transcode 1 */
125 #define TRANSCODE1_TITLE _("Transcode")
126 #define TRANSCODE1_TEXT _("Changes the compression format " \
127         "of the audio or video tracks. To change only the " \
128         "container format, proceed to the next page.")
129
130 #define TR_VIDEO_TEXT0 _("Transcode video (if available)" )
131 #define TR_VIDEO_TEXT _("Select the target video codec. Choose a codec to " \
132                         "display more information about it.")
133
134 #define TR_AUDIO_TEXT0 _("Transcode audio (if available)"
135 #define TR_AUDIO_TEXT _("Select the target audio codec. Choose a codec to " \
136                         "display more information about it.")
137
138 /* Streaming 1 */
139 #define STREAMING1_TITLE _("Streaming")
140 #define STREAMING1_TEXT _("Determines how the input stream will be sent.")
141
142
143 #define INVALID_MCAST_ADDRESS _("This does not appear to be a valid " \
144                                 "multicast address" )
145 #define NO_ADDRESS_TEXT _("Please enter an address" )
146
147 /* Encap  */
148 #define ENCAP_TITLE _("Encapsulation format")
149 #define ENCAP_TEXT _("Determines how the stream will be encapsulated. " \
150                      "Depending on the previous choices, some formats " \
151                      "might not be available." )
152
153
154 /* Transcode 2 */
155 #define EXTRATRANSCODE_TITLE _("Additional transcode options")
156 #define EXTRATRANSCODE_TEXT _("Defines a few additional parameters " \
157                               "for the transcoding." )
158
159 #define CHOOSE_OUTFILE _("You must choose a file to save to")
160
161 /* Streaming 2 */
162 #define EXTRASTREAMING_TITLE _("Additional streaming options")
163 #define EXTRASTREAMING_TEXT _("Defines a few additional parameters " \
164                               "for the stream." )
165
166 #define TTL _("Define the TTL (Time-To-Live) of the stream. This parameter " \
167               "is the maximum number of routers your stream can go through. " \
168               "If you don't know what it means, or if you want to stream on " \
169               "your local network only, leave this setting to 1." )
170
171 #define SAP _("When streaming using RTP, you can announce your streams " \
172               "using the SAP/SDP announcing protocol. This way, the clients " \
173               "won't have to type in the multicast address, it will appear " \
174               "in their playlist if they enable the SAP extra interface.\n" \
175               "If you want to give a name to your stream, enter it here. " \
176               "Otherwise, a default name will be used." )
177
178 /*****************************************************************************
179  * All the pages of the wizard, declaration
180  *****************************************************************************/
181
182 /* Declare classes */
183 class wizHelloPage : public wxWizardPageSimple
184 {
185     public:
186         wizHelloPage( wxWizard *parent);
187         void OnActionChange( wxCommandEvent& event );
188         void OnWizardPageChanging(wxWizardEvent& event);
189         void OnMoreInfo( wxCommandEvent& event );
190     protected:
191         int i_action;
192         WizardDialog *p_parent;
193         wxRadioButton *action_radios[2];
194         DECLARE_EVENT_TABLE()
195 };
196
197 BEGIN_EVENT_TABLE(wizHelloPage, wxWizardPageSimple)
198     EVT_RADIOBUTTON( ActionRadio0_Event, wizHelloPage::OnActionChange)
199     EVT_RADIOBUTTON( ActionRadio1_Event, wizHelloPage::OnActionChange)
200     EVT_BUTTON( MoreInfoStreaming_Event, wizHelloPage::OnMoreInfo )
201     EVT_BUTTON( MoreInfoTranscode_Event, wizHelloPage::OnMoreInfo )
202
203     EVT_WIZARD_PAGE_CHANGING(-1, wizHelloPage::OnWizardPageChanging)
204 END_EVENT_TABLE()
205
206
207 class wizInputPage : public wxWizardPage
208 {
209     public:
210         wizInputPage( wxWizard *, wxWizardPage *, intf_thread_t *);
211         wizInputPage::~wizInputPage();
212         void OnWizardPageChanging(wxWizardEvent& event);
213         void OnInputChange( wxCommandEvent& event );
214         void OnEnablePartial(wxCommandEvent& event);
215         virtual wxWizardPage *GetPrev() const;
216         virtual wxWizardPage *GetNext() const;
217         void SetStreamingPage( wxWizardPage *page);
218         void SetTranscodePage( wxWizardPage *page);
219         void SetAction( int i_action );
220         void SetPintf( intf_thread_t *p_intf );
221         void SetUri( char *psz_uri );
222         void SetPartial( int i_from, int i_to );
223
224     protected:
225         bool b_chosen;
226         intf_thread_t *p_intf;
227         int i_action;
228         int i_input;
229
230         void OnChoose( wxCommandEvent& event );
231
232         WizardDialog *p_parent;
233         wxRadioButton *input_radios[2];
234         wxCheckBox *enable_checkbox;
235         wxBoxSizer *mainSizer;
236         wxArrayString mrl;
237         wxTextCtrl *mrl_text;
238         wxTextCtrl *from_text;
239         wxTextCtrl *to_text;
240         OpenDialog *p_open_dialog;
241         wxListView *listview;
242         wxPanel *open_panel;
243         wxPanel *radio_panel; /* radio buttons should be in their own panel... */
244         wxWizardPage *p_prev;
245         wxWizardPage *p_streaming_page;
246         wxWizardPage *p_transcode_page;
247
248         DECLARE_EVENT_TABLE()
249 };
250
251 BEGIN_EVENT_TABLE(wizInputPage, wxWizardPage)
252     EVT_RADIOBUTTON( InputRadio0_Event, wizInputPage::OnInputChange)
253     EVT_RADIOBUTTON( InputRadio1_Event, wizInputPage::OnInputChange)
254     EVT_BUTTON( Choose_Event, wizInputPage::OnChoose)
255     EVT_CHECKBOX( PartialEnable_Event, wizInputPage::OnEnablePartial)
256     EVT_WIZARD_PAGE_CHANGING(-1, wizInputPage::OnWizardPageChanging)
257 END_EVENT_TABLE()
258
259
260 class wizTranscodeCodecPage : public wxWizardPage
261 {
262 public:
263     wizTranscodeCodecPage( wxWizard *parent, wxWizardPage *next);
264     ~wizTranscodeCodecPage();
265     void wizTranscodeCodecPage::OnWizardPageChanging(wxWizardEvent& event);
266     virtual wxWizardPage *GetPrev() const;
267     virtual wxWizardPage *GetNext() const;
268     void SetPrev( wxWizardPage *page);
269 protected:
270     wxCheckBox *video_checkbox;
271     wxComboBox *video_combo;
272     wxComboBox *vb_combo;
273     wxStaticText * video_text;
274     wxCheckBox *audio_checkbox;
275     wxComboBox *audio_combo;
276     wxComboBox *ab_combo;
277     wxStaticText * audio_text;
278
279     WizardDialog *p_parent;
280     int i_audio_codec;
281     int i_video_codec;
282
283     char *vcodec;
284     char *acodec;
285
286     wxWizardPage *p_prev;
287     wxWizardPage *p_next;
288
289     void OnVideoCodecChange(wxCommandEvent& event);
290     void OnAudioCodecChange(wxCommandEvent& event);
291     void OnEnableVideo(wxCommandEvent& event);
292     void OnEnableAudio(wxCommandEvent& event);
293
294     DECLARE_EVENT_TABLE()
295 };
296
297 BEGIN_EVENT_TABLE(wizTranscodeCodecPage, wxWizardPage)
298    EVT_CHECKBOX( VideoEnable_Event, wizTranscodeCodecPage::OnEnableVideo)
299    EVT_CHECKBOX( AudioEnable_Event, wizTranscodeCodecPage::OnEnableAudio)
300    EVT_COMBOBOX( VideoCodec_Event, wizTranscodeCodecPage::OnVideoCodecChange)
301    EVT_COMBOBOX( AudioCodec_Event, wizTranscodeCodecPage::OnAudioCodecChange)
302    EVT_WIZARD_PAGE_CHANGING(-1, wizTranscodeCodecPage::OnWizardPageChanging)
303 END_EVENT_TABLE()
304
305 class wizStreamingMethodPage : public wxWizardPage
306 {
307 public:
308     wizStreamingMethodPage( intf_thread_t *p_this, wxWizard *parent,
309                             wxWizardPage *next) ;
310     void OnWizardPageChanging(wxWizardEvent& event);
311     virtual wxWizardPage *GetPrev() const;
312     virtual wxWizardPage *GetNext() const;
313     void SetPrev( wxWizardPage *page);
314 protected:
315     DECLARE_EVENT_TABLE()
316     int i_method;
317     wxBoxSizer *mainSizer;
318     wxStaticBoxSizer *address_sizer;
319     wxStaticText *address_text;
320     wxTextCtrl *address_txtctrl;
321     WizardDialog * p_parent;
322     void OnMethodChange( wxCommandEvent& event );
323     wxRadioButton *method_radios[4];
324     wxWizardPage *p_prev;
325     wxWizardPage *p_next;
326     intf_thread_t *p_intf;
327 };
328
329 BEGIN_EVENT_TABLE(wizStreamingMethodPage, wxWizardPage)
330     EVT_RADIOBUTTON( MethodRadio0_Event, wizStreamingMethodPage::OnMethodChange)
331     EVT_RADIOBUTTON( MethodRadio1_Event, wizStreamingMethodPage::OnMethodChange)
332     EVT_RADIOBUTTON( MethodRadio2_Event, wizStreamingMethodPage::OnMethodChange)
333     EVT_RADIOBUTTON( MethodRadio3_Event, wizStreamingMethodPage::OnMethodChange)
334     EVT_WIZARD_PAGE_CHANGING(-1, wizStreamingMethodPage::OnWizardPageChanging)
335 END_EVENT_TABLE()
336
337
338 class wizEncapPage : public wxWizardPage
339 {
340 public:
341     wizEncapPage( wxWizard *parent);
342     wizEncapPage::~wizEncapPage();
343     void OnWizardPageChanging(wxWizardEvent& event);
344     virtual wxWizardPage *GetPrev() const;
345     virtual wxWizardPage *GetNext() const;
346     void SetStreamingPage( wxWizardPage *page);
347     void SetTranscodePage( wxWizardPage *page);
348     void SetPrev( wxWizardPage *page);
349     void SetAction( int );
350     void EnableEncap( int encap );
351 protected:
352     DECLARE_EVENT_TABLE()
353     int i_encap;
354     int i_mux;
355     int i_action;
356     void OnEncapChange( wxCommandEvent& event );
357     wxRadioButton *encap_radios[MUXERS_NUMBER];
358     WizardDialog *p_parent;
359     wxWizardPage *p_prev;
360     wxWizardPage *p_streaming_page;
361     wxWizardPage *p_transcode_page;
362 };
363
364 BEGIN_EVENT_TABLE(wizEncapPage, wxWizardPage)
365     EVT_WIZARD_PAGE_CHANGING(-1, wizEncapPage::OnWizardPageChanging)
366     EVT_RADIOBUTTON( EncapRadio0_Event, wizEncapPage::OnEncapChange)
367     EVT_RADIOBUTTON( EncapRadio1_Event, wizEncapPage::OnEncapChange)
368     EVT_RADIOBUTTON( EncapRadio2_Event, wizEncapPage::OnEncapChange)
369     EVT_RADIOBUTTON( EncapRadio3_Event, wizEncapPage::OnEncapChange)
370     EVT_RADIOBUTTON( EncapRadio4_Event, wizEncapPage::OnEncapChange)
371     EVT_RADIOBUTTON( EncapRadio5_Event, wizEncapPage::OnEncapChange)
372     EVT_RADIOBUTTON( EncapRadio6_Event, wizEncapPage::OnEncapChange)
373     EVT_RADIOBUTTON( EncapRadio7_Event, wizEncapPage::OnEncapChange)
374     EVT_RADIOBUTTON( EncapRadio8_Event, wizEncapPage::OnEncapChange)
375     EVT_RADIOBUTTON( EncapRadio9_Event, wizEncapPage::OnEncapChange)
376     EVT_RADIOBUTTON( EncapRadio10_Event, wizEncapPage::OnEncapChange)
377 END_EVENT_TABLE()
378
379 /* Additional settings for transcode */
380 class wizTranscodeExtraPage : public wxWizardPage
381 {
382 public:
383     wizTranscodeExtraPage( wxWizard *parent, wxWizardPage *prev,
384                             wxWizardPage *next);
385     virtual wxWizardPage *GetPrev() const;
386     virtual wxWizardPage *GetNext() const;
387     void OnWizardPageChanging( wxWizardEvent& event );
388 protected:
389     DECLARE_EVENT_TABLE()
390     void wizTranscodeExtraPage::OnSelectFile(wxCommandEvent&);
391     wxTextCtrl *file_text;
392     WizardDialog *p_parent;
393     wxWizardPage *p_prev;
394     wxWizardPage *p_next;
395 };
396
397 BEGIN_EVENT_TABLE(wizTranscodeExtraPage, wxWizardPage)
398     EVT_BUTTON( Open_Event, wizTranscodeExtraPage::OnSelectFile)
399     EVT_WIZARD_PAGE_CHANGING(-1, wizTranscodeExtraPage::OnWizardPageChanging)
400 END_EVENT_TABLE()
401
402 /* Additional settings for streaming */
403 class wizStreamingExtraPage : public wxWizardPage
404 {
405 public:
406     wizStreamingExtraPage( wxWizard *parent, wxWizardPage *prev,
407                             wxWizardPage *next);
408     virtual wxWizardPage *GetPrev() const;
409     virtual wxWizardPage *GetNext() const;
410     void OnWizardPageChanging(wxWizardEvent&);
411     void OnSAP( wxCommandEvent&);
412     wxCheckBox *sap_checkbox;
413     wxTextCtrl *sap_text;
414 protected:
415     friend class wizEncapPage;
416     DECLARE_EVENT_TABLE()
417     WizardDialog *p_parent;
418     wxWizardPage *p_prev;
419     wxWizardPage *p_next;
420
421     wxSpinCtrl *ttl_spin;
422 };
423
424 BEGIN_EVENT_TABLE(wizStreamingExtraPage, wxWizardPage)
425     EVT_CHECKBOX( SAP_Event, wizStreamingExtraPage::OnSAP )
426     EVT_WIZARD_PAGE_CHANGING(-1, wizStreamingExtraPage::OnWizardPageChanging)
427 END_EVENT_TABLE()
428
429
430 /* Local functions */
431 static void pageHeader( wxWindow *window, wxBoxSizer *sizer,
432                        char *psz_title, char *psz_text);
433
434 static void pageHeader( wxWindow *window, wxBoxSizer *sizer,
435                         char *psz_title, char *psz_text)
436 {
437     wxStaticText *wtitle = new wxStaticText( window, -1, wxU( psz_title ) );
438     wxFont font = wtitle->GetFont();
439     font.SetPointSize(14);
440     wtitle->SetFont(font);
441     sizer->Add( wtitle, 0, wxALL, 5 );
442     sizer->Add( new wxStaticText( window, -1,
443                 wxU( vlc_wraptext( psz_text , TEXTWIDTH ) ) ),
444                         0, wxALL, 5 );
445 }
446
447 /***************************************************************************
448  * Implementation of the pages
449  ***************************************************************************/
450
451
452 /***************************************************
453  * First page: choose between stream and transcode *
454  ***************************************************/
455 wizHelloPage::wizHelloPage( wxWizard *parent) : wxWizardPageSimple(parent)
456 {
457         i_action = 0;
458         p_parent = (WizardDialog *)parent;
459         wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
460
461         /* Create the texts */
462         pageHeader( this, mainSizer, HELLO_TITLE, HELLO_TEXT );
463
464         /* Create the radio buttons with their helps */
465         action_radios[0] = new wxRadioButton( this, ActionRadio0_Event,
466                                               wxU( HELLO_STREAMING ) );
467         action_radios[1] = new wxRadioButton( this, ActionRadio1_Event,
468                                               wxU( HELLO_TRANSCODE ) );
469         i_action = 0;
470
471         mainSizer->Add( 0, 0, 1 );
472
473         wxBoxSizer *stream_sizer = new wxBoxSizer( wxHORIZONTAL );
474         stream_sizer->Add( action_radios[0], 0, wxALL, 5 );
475         stream_sizer->Add( 0,0,1 );
476         stream_sizer->Add( new wxButton( this, MoreInfoStreaming_Event,
477                                 wxU( _("More Info")) ), 0, 0, 0 );
478         mainSizer->Add( stream_sizer, 0, wxALL | wxEXPAND , 5 );
479
480         wxBoxSizer *transcode_sizer = new wxBoxSizer( wxHORIZONTAL );
481         transcode_sizer->Add( action_radios[1], 0, wxALL, 5 );
482         transcode_sizer->Add( 0,0,1);
483         transcode_sizer->Add( new wxButton( this, MoreInfoTranscode_Event,
484                                 wxU( _("More Info")) ), 0 ,  0 , 0 );
485         mainSizer->Add( transcode_sizer, 0, wxALL | wxEXPAND, 5 );
486
487         mainSizer->Add( 0, 0, 1 );
488
489         mainSizer->Add( new wxStaticLine(this, -1 ), 0, wxEXPAND| wxTOP|
490                         wxBOTTOM, 5 );
491
492         mainSizer->Add( new wxStaticText(this, -1,
493                         wxU( vlc_wraptext(HELLO_NOTICE , TEXTWIDTH ))),
494                         0, wxALL, 5 );
495
496         SetSizer(mainSizer);
497         mainSizer->Fit(this);
498     }
499
500 void wizHelloPage::OnMoreInfo(wxCommandEvent& event)
501 {
502     wxString msg;
503     msg.Printf( wxString( wxU( event.GetId() == MoreInfoStreaming_Event ?
504                                     MOREINFO_STREAM :
505                                     MOREINFO_TRANSCODE ) ) );
506     wxMessageBox( msg, wxU(_("More information")),
507                   wxOK | wxICON_INFORMATION, this->p_parent );
508 }
509
510 void wizHelloPage::OnActionChange( wxCommandEvent& event )
511 {
512     i_action = event.GetId() - ActionRadio0_Event;
513     ((wizInputPage *)GetNext())->SetAction( i_action );
514     p_parent->SetAction( i_action );
515 }
516
517 void wizHelloPage::OnWizardPageChanging(wxWizardEvent& event)
518 {
519     ((wizInputPage *)GetNext())->SetAction( i_action );
520     p_parent->SetAction( i_action );
521 }
522
523 /************************************
524  * Second page: choose input stream *
525  ************************************/
526 wizInputPage::wizInputPage( wxWizard *parent, wxWizardPage *prev, intf_thread_t *_p_intf) :
527               wxWizardPage(parent)
528 {
529     p_prev = prev;
530     p_intf = _p_intf;
531     p_parent = (WizardDialog *)parent;
532     b_chosen = false;
533     p_open_dialog = NULL;
534     listview = NULL;
535     mrl_text = NULL;
536     mainSizer = new wxBoxSizer(wxVERTICAL);
537
538     /* Create the texts */
539     pageHeader( this, mainSizer, INPUT_TITLE, INPUT_TEXT );
540
541     mainSizer->Add( 0,20,0 );
542
543     radio_panel = new wxPanel(this, -1);
544     radio_panel->SetAutoLayout( TRUE );
545
546     wxBoxSizer *radioSizer = new wxBoxSizer(wxVERTICAL);
547
548     /* Create the radio buttons */
549     input_radios[0] = new wxRadioButton( radio_panel, InputRadio0_Event ,
550                                wxU( INPUT_OPEN ) );
551     radioSizer->Add( input_radios[0], 0, wxALL, 5 );
552     input_radios[1] = new wxRadioButton( radio_panel, InputRadio1_Event ,
553                                wxU( INPUT_PL ) );  
554     radioSizer->Add( input_radios[1], 0, wxALL, 5 );
555
556     radio_panel->SetSizer( radioSizer );
557     radioSizer->Layout();
558     radioSizer->Fit(radio_panel);
559     mainSizer->Add( radio_panel );
560
561     i_input = 0;
562
563     /* Open Panel */
564     open_panel = new wxPanel(this, -1);
565     open_panel->SetAutoLayout( TRUE );
566
567     wxBoxSizer *openSizer = new wxBoxSizer(wxHORIZONTAL);
568
569     mrl_text = new wxTextCtrl( open_panel, -1, wxU( "" ), wxDefaultPosition,
570                               wxSize(200,25) );
571
572     openSizer->Add( mrl_text, 0 , wxALL, 5 );
573     openSizer->Add( new wxButton( open_panel, Choose_Event, wxU(_("Choose...")) ), 0, wxALL, 5 );
574
575     open_panel->SetSizer( openSizer );
576     openSizer->Layout();
577     openSizer->Fit(open_panel);
578     mainSizer->Add( open_panel );
579
580     playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_intf,
581                                        VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
582
583     if( p_playlist )
584     {
585         if( !playlist_IsEmpty( p_playlist ) )
586         {
587             listview = new wxListView( this, ListView_Event,
588                                        wxDefaultPosition, wxDefaultSize,
589                                        wxLC_REPORT | wxSUNKEN_BORDER );
590             listview->InsertColumn( 0, wxU(_("Name")) );
591             listview->InsertColumn( 1, wxU(_("URI")) );
592             listview->SetColumnWidth( 0, 250 );
593             listview->SetColumnWidth( 1, 100 );
594             mainSizer->Add( listview, 1, wxALL|wxEXPAND, 5 );
595
596             listview->Hide();
597             mainSizer->Hide( listview );
598             mainSizer->Layout();
599         }
600         else
601         {
602             input_radios[1]->Disable();
603         }
604         vlc_object_release( p_playlist );
605     }
606     else
607     {
608         input_radios[1]->Disable();
609     }
610
611     /* Partial Extract Box */
612     mainSizer->Add( 0, 10, 0 );
613     wxStaticBox *partial_box = new wxStaticBox( this, -1,
614                     wxU(_("Partial Extract")) );
615
616     wxStaticBoxSizer *partial_sizer = new wxStaticBoxSizer( partial_box,
617                                                           wxVERTICAL );
618
619     enable_checkbox = new wxCheckBox( this, PartialEnable_Event,
620                                                 wxU(_("Enable") ) );
621     enable_checkbox->SetToolTip(wxU(_(PARTIAL) ) ) ;
622     partial_sizer->Add( enable_checkbox, 0 , wxALIGN_CENTER_VERTICAL|wxALL, 5 ); //wxLEFT
623
624     wxFlexGridSizer *partial_sizer2 = new wxFlexGridSizer( 4 , 1 , 20 );
625     partial_sizer2->Add( new wxStaticText(this, -1, wxU(_( "From" ) ) ),
626                          0 , wxLEFT , 5 );
627     from_text = new wxTextCtrl( this, -1, wxT(""),
628                                 wxDefaultPosition, wxSize( 80,25 ) );
629     partial_sizer2->Add( from_text, 0 , wxALIGN_RIGHT);
630     partial_sizer2->Add( new wxStaticText(this, -1, wxU(_( "To" ) ) ),
631                          0 , wxLEFT , 5 );
632     to_text = new wxTextCtrl( this, -1, wxT(""),
633                                   wxDefaultPosition, wxSize( 80 , 25 ) );
634     partial_sizer2->Add( to_text, 0 , wxALIGN_RIGHT );
635
636     partial_sizer->Add( partial_sizer2, 0, wxALL, 0 );
637
638     partial_sizer->Fit( partial_box );
639
640     mainSizer->Add( partial_sizer, 0, 0, 0 );
641
642     from_text->Disable();
643     to_text->Disable();
644     SetSizer(mainSizer);
645     mainSizer->Fit(this);
646     mainSizer->Layout();
647 }
648
649 wizInputPage::~wizInputPage()
650 {
651 }
652
653 void wizInputPage::OnInputChange( wxCommandEvent& event )
654 {
655     i_input = event.GetId() - InputRadio0_Event;
656     if( i_input == 0 )
657     {
658         if( listview )
659         {
660             listview->Hide();
661             mainSizer->Hide( listview );
662             open_panel->Show();
663             mainSizer->Show( open_panel );
664             mainSizer->Layout();
665         }
666     }
667     else
668     {
669         open_panel->Hide();
670         mainSizer->Hide( open_panel );
671         listview->Show();
672         mainSizer->Show( listview );
673         mainSizer->Layout();
674     }
675 }
676
677 void wizInputPage::OnEnablePartial(wxCommandEvent& event)
678 {
679    from_text->Enable( event.IsChecked() );
680    to_text->Enable( event.IsChecked() );
681 }
682
683
684 void wizInputPage::OnChoose(wxCommandEvent& event)
685 {
686     p_open_dialog = new OpenDialog( p_intf, this, -1, -1, OPEN_STREAM );
687     if(  p_open_dialog->ShowModal() == wxID_OK &&
688          !p_open_dialog->mrl.IsEmpty() )
689     {
690         mrl_text->SetValue(p_open_dialog->mrl[0] );
691     }
692     delete p_open_dialog;
693     p_open_dialog = NULL;
694 }
695
696 void wizInputPage::OnWizardPageChanging(wxWizardEvent& event)
697 {
698     if( i_input == 0)
699     {
700         if( mrl_text->GetValue().IsSameAs( wxT(""), TRUE ) &&
701                         event.GetDirection() )
702         {
703             wxMessageBox( wxU( CHOOSE_STREAM ), wxU( ERROR_MSG ),
704                           wxICON_WARNING | wxOK, this->p_parent );
705             event.Veto();
706             return;
707         }
708         else
709         {
710             p_parent->SetMrl( (const char *)mrl_text->GetValue().mb_str() );
711         }
712     }
713     else
714     {
715         int i = -1;
716         i = listview->GetNextItem( i , wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
717         if( i != -1 )
718         {
719             long data = listview->GetItemData( i );
720             playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_intf,
721                                       VLC_OBJECT_PLAYLIST, FIND_ANYWHERE);
722             if( p_playlist )
723             {
724                 playlist_item_t * p_item = playlist_LockItemGetById(
725                                                    p_playlist, (int)data );
726                 if( p_item )
727                 {
728                     p_parent->SetMrl( (const char*)p_item->p_input->psz_uri );
729                 }
730                 else
731                     event.Veto();
732             }
733             else
734                 event.Veto();
735         }
736     }
737     if( enable_checkbox->IsChecked() )
738     {
739         int i_from = atoi( from_text->GetValue().mb_str() );
740         int i_to = atoi( to_text->GetValue().mb_str() );
741         p_parent->SetPartial( i_from, i_to );
742     }
743     return;
744 }
745
746 wxWizardPage *wizInputPage::GetPrev() const { return p_prev; }
747 wxWizardPage *wizInputPage::GetNext() const
748 {
749     if( i_action == ACTION_STREAM )
750         return p_streaming_page;
751     else
752        return p_transcode_page;
753 }
754
755 void wizInputPage::SetStreamingPage( wxWizardPage *page)
756 {
757     p_streaming_page = page;
758 }
759
760 void wizInputPage::SetTranscodePage( wxWizardPage *page)
761 {
762     p_transcode_page = page;
763 }
764
765 void wizInputPage::SetAction( int i_action )
766 {
767     this->i_action = i_action;
768 }
769
770 void wizInputPage::SetPintf( intf_thread_t *p_intf )
771 {
772     this->p_intf = p_intf;
773 }
774
775 void wizInputPage::SetUri( char *psz_uri )
776 {
777     mrl_text->SetValue( wxU( psz_uri ) );
778 }
779
780 void wizInputPage::SetPartial( int i_from, int i_to )
781 {
782    wxString msg;
783    msg.Printf( wxString( wxT( "%i") ), i_from );
784    from_text->Enable( TRUE );
785    from_text->SetValue( msg );
786    msg.Printf( wxString( wxT( "%i") ), i_to );
787    to_text->Enable( TRUE );
788    to_text->SetValue( msg );
789    enable_checkbox->SetValue( TRUE );
790 }
791
792 /***************************************************
793  * First transcode page: choose codecs             *
794  ***************************************************/
795 wizTranscodeCodecPage::wizTranscodeCodecPage( wxWizard *parent,
796                        wxWizardPage *next) : wxWizardPage(parent)
797 {
798     int i;
799
800     p_next = next;
801
802     acodec = NULL;
803     vcodec = NULL;
804     p_parent = (WizardDialog *) parent;
805
806     wxBoxSizer *main_sizer = new wxBoxSizer(wxVERTICAL);
807
808     /* Header */
809     pageHeader( this, main_sizer,  TRANSCODE1_TITLE, TRANSCODE1_TEXT );
810
811     /* Video Box */
812     wxStaticBox *video_box = new wxStaticBox( this, -1, wxU(_("Video")) );
813     wxStaticBoxSizer *video_sizer = new wxStaticBoxSizer( video_box,
814                                                           wxVERTICAL );
815     /* Line 1 : only the checkbox */
816     wxFlexGridSizer *video_sizer1 = new wxFlexGridSizer( 2,3,20 );
817     video_sizer1->Add( new wxCheckBox( this, VideoEnable_Event,
818                        wxU(_("Transcode video") ) ), 0 , wxALIGN_CENTER_VERTICAL|wxALL , 5 );
819     video_sizer1->Add( 0,0,1);
820     /* Line 2 : codec */
821     video_sizer1->Add( new wxStaticText(this, -1, wxU(_("Codec"))),0,wxLEFT ,5);
822     video_combo = new wxComboBox( this, VideoCodec_Event, wxT(""),
823                                   wxDefaultPosition, wxSize(200,25), 0, NULL, 
824                                   wxCB_DROPDOWN| wxCB_READONLY );
825     for( i= 0; vcodecs_array[i].psz_display != NULL; i++ )
826     {
827         video_combo->Append( wxU( vcodecs_array[i].psz_display ) ,
828                             (void *)&vcodecs_array[i] );
829     }
830     i_video_codec = 0;
831     video_combo->SetSelection(0);
832
833     video_sizer1->Add( video_combo, 0 , wxALIGN_LEFT , 0 );
834
835     video_sizer1->Add( new wxStaticText(this, -1, wxU(_("Bitrate (kb/s)"))),0,
836                        wxLEFT ,5);
837     vb_combo = new wxComboBox( this, VideoBitrate_Event, wxT("1024"),
838                                wxDefaultPosition, wxDefaultSize,
839                                WXSIZEOF(vbitrates_array), vbitrates_array, wxCB_READONLY );
840     video_sizer1->Add( vb_combo, 0, wxALIGN_LEFT , 0 );
841
842     /* Line 3 : text */
843     video_text = new wxStaticText( this, -1,
844                      wxU( vlc_wraptext( TR_VIDEO_TEXT, TEXTWIDTH ) ) );
845     /* Fill the main video sizer */
846     video_sizer->Add( video_sizer1 , 0, wxEXPAND , 5 );
847     video_sizer->Add( video_text, 0, wxLEFT|wxTOP , 5 );
848
849
850     /* Audio box */
851     wxStaticBox *audio_box = new wxStaticBox( this, -1, wxU(_("Audio")) );
852     wxStaticBoxSizer *audio_sizer = new wxStaticBoxSizer( audio_box,
853                                                           wxVERTICAL );
854     /* Line1: enabler */
855     wxFlexGridSizer *audio_sizer1 = new wxFlexGridSizer( 2,3,20);
856     audio_sizer1->Add( new wxCheckBox( this, AudioEnable_Event,
857                             wxU(_("Transcode audio") ) ), 0 , wxALIGN_CENTER_VERTICAL|wxALL, 5 );
858     audio_sizer1->Add( 0, 0, 1 );
859
860     /* Line 2 : codec */
861     audio_sizer1->Add( new wxStaticText(this, -1, wxU(_("Codec"))),0,wxLEFT,5);
862     audio_combo = new wxComboBox( this, AudioCodec_Event, wxT(""),
863                                   wxDefaultPosition, wxSize(200,25), 0, NULL, 
864                                   wxCB_DROPDOWN| wxCB_READONLY );
865     for( i= 0; acodecs_array[i].psz_display != NULL; i++ )
866     {
867         audio_combo->Append( wxU( acodecs_array[i].psz_display ) ,
868                             (void *)&acodecs_array[i] );
869     }
870     i_audio_codec = 0;
871     audio_combo->SetSelection(0);
872     audio_sizer1->Add( audio_combo, 0 , wxALIGN_LEFT, 0 );
873
874     audio_sizer1->Add( new wxStaticText(this, -1, wxU(_("Bitrate (kb/s)"))),0,
875                        wxLEFT ,5);
876     ab_combo = new wxComboBox( this, AudioBitrate_Event, wxT("192"),
877                                wxDefaultPosition, wxDefaultSize,
878                                WXSIZEOF(abitrates_array), abitrates_array, wxCB_READONLY );
879     audio_sizer1->Add( ab_combo, 0, wxALIGN_LEFT, 0 );
880
881     /* Line 3 : text */
882     audio_text = new wxStaticText( this, -1,
883                      wxU( vlc_wraptext( TR_AUDIO_TEXT, TEXTWIDTH ) ) );
884
885     audio_sizer->Add(audio_sizer1, 0, wxEXPAND, 5);
886     audio_sizer->Add( audio_text, 0, wxLEFT | wxTOP, 5 );
887
888     main_sizer->Add( video_sizer, 1, wxGROW, 0 );
889     main_sizer->Add( audio_sizer, 1, wxGROW, 0 );
890     main_sizer->Layout();
891     SetSizerAndFit( main_sizer );
892
893     /* Default disabled */
894     video_combo->Disable(); video_text->Disable();vb_combo->Disable();
895     audio_combo->Disable(); audio_text->Disable();ab_combo->Disable();
896
897 }
898
899 wizTranscodeCodecPage::~wizTranscodeCodecPage()
900 {
901     if( acodec ) free( acodec );
902     if( vcodec ) free( vcodec );
903 }
904
905 void wizTranscodeCodecPage::OnEnableVideo(wxCommandEvent& event)
906 {
907    video_combo->Enable( event.IsChecked() );
908    vb_combo->Enable( event.IsChecked() );
909    video_text->Enable( event.IsChecked() );
910 }
911
912 void wizTranscodeCodecPage::OnEnableAudio(wxCommandEvent& event)
913 {
914    audio_combo->Enable( event.IsChecked() );
915    ab_combo->Enable( event.IsChecked() );
916    audio_text->Enable( event.IsChecked() );
917 }
918
919 void wizTranscodeCodecPage::OnVideoCodecChange(wxCommandEvent& event)
920 {
921     struct codec *c = (struct codec*)
922              (video_combo->GetClientData(video_combo->GetSelection()));
923     video_text->SetLabel( wxU( vlc_wraptext(c->psz_descr, TEXTWIDTH ) ) );
924     i_video_codec = video_combo->GetSelection();
925     vcodec = strdup(c->psz_codec);
926 }
927
928 void wizTranscodeCodecPage::OnAudioCodecChange(wxCommandEvent& event)
929 {
930     struct codec *c = (struct codec*)
931              (audio_combo->GetClientData(audio_combo->GetSelection()));
932     audio_text->SetLabel( wxU( vlc_wraptext(c->psz_descr, TEXTWIDTH ) ) );
933     i_audio_codec = audio_combo->GetSelection();
934     acodec = strdup(c->psz_codec);
935
936 }
937
938 void wizTranscodeCodecPage::OnWizardPageChanging(wxWizardEvent& event)
939 {
940     unsigned int i,j;
941
942     if( !event.GetDirection() )
943     {
944             GetPrev()->Enable();
945             return;
946     }
947
948     /* Set the dummy codec ( accept all muxers ) if needed */
949     if( !video_combo->IsEnabled() )
950     {
951         i_video_codec = VCODECS_NUMBER;
952     }
953     if( !audio_combo->IsEnabled() )
954     {
955         i_audio_codec = ACODECS_NUMBER;
956     }
957
958     ((wizEncapPage *)GetNext())->SetPrev(this);
959
960     for( i = 0 ; i< MUXERS_NUMBER ; i++ )
961     {
962         if( vcodecs_array[i_video_codec].muxers[i] != -1 )
963         {
964             for( j = 0 ; j<  MUXERS_NUMBER ; j++ )
965             {
966                 if( acodecs_array[i_audio_codec].muxers[j] ==
967                               vcodecs_array[i_video_codec].muxers[i] )
968                 {
969                     ((wizEncapPage*)GetNext())->EnableEncap(
970                                vcodecs_array[i_video_codec].muxers[i] );
971                 }
972             }
973         }
974     }
975     struct codec *c = (struct codec*)
976              (video_combo->GetClientData( video_combo->IsEnabled() ?
977                                           video_combo->GetSelection(): i_video_codec ));
978     vcodec = strdup(c->psz_codec);
979     c = (struct codec*)
980            (audio_combo->GetClientData( audio_combo->IsEnabled() ?
981                                        audio_combo->GetSelection() : i_audio_codec ));
982     acodec = strdup(c->psz_codec);
983
984     int vb = atoi(vb_combo->GetValue().mb_str() );
985     if( vb == 0 )
986     {
987          vb = 1024;
988     }
989     int ab = atoi(ab_combo->GetValue().mb_str() );
990     if( ab == 0)
991     {
992         ab = 192;
993     }
994
995     p_parent->SetTranscode( vcodec, vb , acodec, ab );
996     ((wizEncapPage*)GetNext())->SetAction( p_parent->GetAction() );
997     p_parent->SetAction( p_parent->GetAction() );
998
999     return;
1000 }
1001
1002 wxWizardPage *wizTranscodeCodecPage::GetPrev() const { return p_prev; }
1003 wxWizardPage *wizTranscodeCodecPage::GetNext() const { return p_next; }
1004 void wizTranscodeCodecPage::SetPrev( wxWizardPage *page) {p_prev = page; }
1005
1006
1007 /***************************************************
1008  * First streaming page: choose method             *
1009  ***************************************************/
1010 wizStreamingMethodPage::wizStreamingMethodPage( intf_thread_t *p_this, wxWizard *parent,
1011     wxWizardPage *next) : wxWizardPage(parent), p_intf( p_this )
1012 {
1013     int i;
1014     p_next = next;
1015     p_parent = (WizardDialog *)parent;
1016
1017     mainSizer = new wxBoxSizer(wxVERTICAL);
1018
1019     /* Create the texts */
1020     pageHeader( this, mainSizer,  STREAMING1_TITLE, STREAMING1_TEXT );
1021
1022     mainSizer->Add( 0,50,0 );
1023
1024     i_method = 0;
1025
1026     wxStaticBox *method_box = new wxStaticBox( this, -1,
1027                                                wxU(_("Streaming method")) );
1028     wxStaticBoxSizer *method_sizer = new wxStaticBoxSizer(method_box,
1029                                                           wxHORIZONTAL );
1030     for( i = 0 ; i< 3 ; i++ )
1031     {
1032         method_radios[i] = new wxRadioButton( this, MethodRadio0_Event + i,
1033                                wxU( methods_array[i].psz_method ) );
1034         method_radios[i]->SetToolTip( wxU(_( methods_array[i].psz_descr ) ) );
1035         method_sizer->Add( method_radios[i], 0, wxALL, 5 );
1036     }
1037
1038     method_sizer->Layout();
1039
1040     wxStaticBox *address_box = new wxStaticBox( this, -1,
1041                     wxU(_("Destination")) );
1042
1043     address_sizer = new wxStaticBoxSizer(address_box,
1044                                          wxVERTICAL );
1045
1046     /* Big kludge, we take the longest text to get the size */
1047     address_text = new wxStaticText(this, -1,
1048                wxU( vlc_wraptext(methods_array[2].psz_address, TEXTWIDTH ) ),
1049                wxDefaultPosition, wxDefaultSize );
1050
1051     address_txtctrl = new wxTextCtrl( this, -1, wxU(""), wxDefaultPosition,
1052                                       wxSize(200,25));
1053     address_sizer->Add( address_text, 0, wxALL, 5 );
1054     address_sizer->Add( address_txtctrl, 0, wxALL, 5 );
1055     address_sizer->Layout();
1056
1057     /* Set the minimum size */
1058     address_sizer->SetMinSize( address_sizer->GetSize() );
1059     address_text->SetLabel( wxU(
1060      vlc_wraptext( _(methods_array[0].psz_address), TEXTWIDTH )));
1061
1062     mainSizer->Add( method_sizer, 0, wxALL | wxEXPAND, 5 );
1063     mainSizer->Add( address_sizer, 0, wxALL | wxEXPAND, 5 );
1064
1065     mainSizer->Add( 0,0,1 );
1066
1067     mainSizer->Layout();
1068
1069     SetSizer(mainSizer);
1070     mainSizer->Fit(this);
1071
1072     return;
1073 }
1074
1075 void wizStreamingMethodPage::OnWizardPageChanging(wxWizardEvent& event)
1076 {
1077     unsigned int i;
1078     if( !event.GetDirection() ) return;
1079
1080     /* Check valid address */
1081     if( i_method == 1
1082      && !net_AddressIsMulticast( (vlc_object_t *)p_intf,
1083                                  address_txtctrl->GetValue().mb_str()) )
1084     {
1085         wxMessageBox( wxU( INVALID_MCAST_ADDRESS ) , wxU( ERROR_MSG ),
1086                       wxICON_WARNING | wxOK, this->p_parent );
1087         event.Veto();
1088
1089     }
1090     else if( i_method == 0 && address_txtctrl->GetValue().IsEmpty() )
1091     {
1092         wxMessageBox( wxU( NO_ADDRESS_TEXT ) , wxU( ERROR_MSG ),
1093                       wxICON_WARNING | wxOK, this->p_parent );
1094         event.Veto();
1095
1096     }
1097
1098     ((wizEncapPage *)GetNext())->SetPrev(this);
1099     for( i = 0 ; i< MUXERS_NUMBER ; i++ )
1100     {
1101         if( methods_array[i_method].muxers[i] != -1 )
1102         {
1103             ((wizEncapPage*)GetNext())->EnableEncap(
1104                                methods_array[i_method].muxers[i] );
1105         }
1106     }
1107     p_parent->SetStream( methods_array[i_method].psz_access ,
1108                          address_txtctrl->GetValue().mb_str() );
1109
1110     /* Set the action for the muxer page */
1111     ((wizEncapPage*)GetNext())->SetAction( p_parent->GetAction() );
1112     return;
1113 }
1114
1115 wxWizardPage *wizStreamingMethodPage::GetPrev() const { return p_prev; }
1116 wxWizardPage *wizStreamingMethodPage::GetNext() const { return p_next; }
1117
1118 void wizStreamingMethodPage::SetPrev( wxWizardPage *page) {p_prev = page; }
1119
1120
1121 void wizStreamingMethodPage::OnMethodChange( wxCommandEvent& event )
1122 {
1123     i_method = event.GetId() - MethodRadio0_Event;
1124     address_text->SetLabel( wxU(
1125      vlc_wraptext( _(methods_array[i_method].psz_address), TEXTWIDTH )));
1126     address_sizer->Layout();
1127     mainSizer->Layout();
1128 }
1129
1130 /***************************************************
1131  * Choose encapsulation format                     *
1132  ***************************************************/
1133 wizEncapPage::wizEncapPage( wxWizard *parent ) : wxWizardPage(parent)
1134 {
1135     int i;
1136     i_mux = 0;
1137     p_parent = (WizardDialog *)parent;
1138     p_streaming_page = NULL;
1139     p_transcode_page = NULL;
1140     p_prev = NULL;
1141     wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
1142
1143     /* Create the texts */
1144     pageHeader( this, mainSizer, ENCAP_TITLE, ENCAP_TEXT );
1145
1146     mainSizer->Add( 0,0,1 );
1147
1148     for( i = 0 ; i< MUXERS_NUMBER ; i++ )
1149     {
1150         encap_radios[i] = new wxRadioButton( this, EncapRadio0_Event + i,
1151                                wxU( encaps_array[i].psz_encap ) );
1152         encap_radios[i]->SetToolTip( wxU(_( encaps_array[i].psz_descr ) ) );
1153         mainSizer->Add( encap_radios[i], 0, wxLEFT, 5 );
1154         encap_radios[i]->Disable();
1155     }
1156
1157     mainSizer->Add( 0,0,1 );
1158
1159     SetSizer(mainSizer);
1160     mainSizer->Fit(this);
1161 }
1162
1163 wizEncapPage::~wizEncapPage()
1164 {
1165 }
1166
1167 void wizEncapPage::OnWizardPageChanging(wxWizardEvent& event)
1168 {
1169     int i;
1170     if( !event.GetDirection() )
1171     {
1172         for( i = 0 ; i< MUXERS_NUMBER ; i++ )
1173         {
1174             encap_radios[i]->Disable();
1175         }
1176     }
1177     p_parent->SetMux( encaps_array[i_mux].psz_mux );
1178
1179     if( p_parent->GetAction() == ACTION_STREAM )
1180     {
1181         if( strstr( p_parent->method, "rtp" ))
1182         {
1183             ((wizStreamingExtraPage *)GetNext())->sap_checkbox->Enable();
1184             ((wizStreamingExtraPage *)GetNext())->sap_text->Enable(false);
1185         }
1186         else
1187         {
1188            ((wizStreamingExtraPage *)GetNext())->sap_checkbox->Enable( false );
1189            ((wizStreamingExtraPage *)GetNext())->sap_text->Enable( false );
1190         }
1191     }
1192
1193     return;
1194 }
1195
1196
1197 void wizEncapPage::OnEncapChange( wxCommandEvent& event )
1198 {
1199     i_mux = event.GetId() - EncapRadio0_Event;
1200 }
1201
1202 void wizEncapPage::EnableEncap( int encap )
1203 {
1204     int i;
1205     for( i = 0 ; i< MUXERS_NUMBER ; i++)
1206     {
1207         if( encaps_array[i].id == encap )
1208         {
1209             encap_radios[i]->Enable();
1210             encap_radios[i]->SetValue(true);
1211             i_mux = i;
1212         }
1213     }
1214 }
1215
1216 void wizEncapPage::SetStreamingPage( wxWizardPage *page)
1217 {
1218     p_streaming_page = page;
1219 }
1220
1221 void wizEncapPage::SetTranscodePage( wxWizardPage *page)
1222 {
1223     p_transcode_page = page;
1224 }
1225
1226 wxWizardPage *wizEncapPage::GetPrev() const { return p_prev; }
1227
1228 wxWizardPage *wizEncapPage::GetNext() const
1229 {
1230     if( i_action== ACTION_STREAM )
1231         return p_streaming_page;
1232     else
1233        return p_transcode_page;
1234 }
1235
1236 void wizEncapPage::SetAction( int i_act  ) { i_action = i_act; }
1237
1238 void wizEncapPage::SetPrev( wxWizardPage *page) { p_prev = page; }
1239
1240 /***************************************************
1241  * Extra transcoding page : Select file            *
1242  ***************************************************/
1243 wizTranscodeExtraPage::wizTranscodeExtraPage( wxWizard *parent,
1244                        wxWizardPage *prev,
1245                        wxWizardPage *next) : wxWizardPage(parent)
1246 {
1247     p_next = next;
1248     p_prev = prev;
1249     p_parent = (WizardDialog *) parent;
1250     wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
1251
1252     /* Create the texts */
1253     pageHeader( this, mainSizer, EXTRATRANSCODE_TITLE, EXTRATRANSCODE_TEXT );
1254
1255     mainSizer->Add( 0, 0, 1 );
1256
1257     wxFlexGridSizer *sizer = new wxFlexGridSizer( 2, 2, 1 );
1258     sizer->Add( new wxStaticText( this, -1,
1259                     wxU(_("Select the file to save to") ) ),
1260                     0, wxALL, 5 );
1261     sizer->Add( 0, 0, 1 );
1262
1263     file_text = new wxTextCtrl( this, -1, wxU(""), wxDefaultPosition,
1264                                 wxSize( 150, -1 ) );
1265
1266     sizer->Add( file_text, 0,  wxALL, 5 );
1267     sizer->Add( new wxButton( this, Open_Event, wxU("Choose") ) );
1268
1269     mainSizer->Add( sizer, 0, 0, 0) ;
1270
1271     mainSizer->Add( 0, 0, 1 );
1272     SetSizer(mainSizer);
1273     mainSizer->Fit(this);
1274 }
1275
1276 void wizTranscodeExtraPage::OnSelectFile( wxCommandEvent &event)
1277 {
1278     wxFileDialog *file_dialog =  new wxFileDialog( this, wxU(_("Save to file")),
1279                    wxT(""), wxT(""), wxT("*"), wxSAVE );
1280
1281     if( file_dialog && file_dialog->ShowModal() == wxID_OK )
1282     {
1283         if( file_dialog->GetFilename().mb_str() )
1284         {
1285             file_text->SetValue( file_dialog->GetPath() );
1286         }
1287     }
1288 }
1289
1290 void wizTranscodeExtraPage::OnWizardPageChanging( wxWizardEvent& event )
1291 {
1292     if( event.GetDirection() && file_text->GetValue().IsEmpty() )
1293     {
1294         wxMessageBox( wxU( CHOOSE_OUTFILE ), wxU( ERROR_MSG ),
1295                       wxICON_WARNING | wxOK, this->p_parent );
1296         event.Veto();
1297     }
1298     if( event.GetDirection() )
1299     {
1300        p_parent->SetTranscodeOut( file_text->GetValue() );
1301     }
1302 }
1303
1304 wxWizardPage *wizTranscodeExtraPage::GetPrev() const { return p_prev; }
1305 wxWizardPage *wizTranscodeExtraPage::GetNext() const {return p_next; }
1306
1307 /***********************************************************
1308  *  Extra streaming page
1309  ***********************************************************/
1310 wizStreamingExtraPage::wizStreamingExtraPage( wxWizard *parent,
1311                        wxWizardPage *prev,
1312                        wxWizardPage *next) : wxWizardPage(parent)
1313 {
1314     p_next = next;
1315     p_prev = prev;
1316     p_parent = (WizardDialog *) parent;
1317     wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
1318
1319     /* Create the texts */
1320     pageHeader( this, mainSizer, EXTRASTREAMING_TITLE, EXTRASTREAMING_TEXT );
1321
1322     mainSizer->Add( 0, 0, 1 );
1323
1324     wxFlexGridSizer *sizer = new wxFlexGridSizer( 2,2,1) ;
1325
1326     /* TTL */
1327     sizer->Add( new wxStaticText( this, -1, wxU(_("Time-To-Live (TTL)"))),
1328                     0, wxALL,  5 );
1329     ttl_spin = new wxSpinCtrl( this, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
1330                     0, 1, 255, 1 );
1331     ttl_spin->SetToolTip(wxU(_(TTL) ) ) ;
1332     sizer->Add( ttl_spin, 0, wxALL , 5 );
1333
1334     /* SAP announce */
1335     sap_checkbox =  new wxCheckBox( this, SAP_Event, wxU(_("SAP Announce")) );
1336     sap_checkbox->SetToolTip( wxU(_( SAP ) ) );
1337     sizer->Add( sap_checkbox, 0, 0 , 0 );
1338     sap_text = new wxTextCtrl( this, -1, wxU(""), wxDefaultPosition,
1339                     wxSize(100,25) );
1340     sap_text->SetToolTip( wxU(_( SAP ) ) );
1341     sizer->Add( sap_text, 0, wxALL , 5 );
1342
1343     mainSizer->Add(sizer, 0, wxALL, 5 );
1344
1345     mainSizer->Add( 0, 0, 1 );
1346
1347     SetSizer(mainSizer);
1348     mainSizer->Fit(this);
1349 }
1350
1351 void wizStreamingExtraPage::OnSAP( wxCommandEvent &event )
1352 {
1353     sap_text->Enable( event.IsChecked() );
1354 }
1355
1356 void wizStreamingExtraPage::OnWizardPageChanging(wxWizardEvent& event)
1357 {
1358     if( sap_checkbox->IsChecked() )
1359     {
1360         if( sap_text->GetValue().IsEmpty() )
1361         {
1362             p_parent->SetSAP( true, NULL );
1363         }
1364         else
1365         {
1366             p_parent->SetSAP( true,
1367                              (const char *)sap_text->GetValue().mb_str() );
1368         }
1369     }
1370     else
1371     {
1372         p_parent->SetSAP( false, NULL );
1373     }
1374
1375     p_parent->SetTTL( ttl_spin->GetValue() );
1376 }
1377
1378 wxWizardPage *wizStreamingExtraPage::GetPrev() const { return p_prev; }
1379 wxWizardPage *wizStreamingExtraPage::GetNext() const {return p_next; }
1380
1381
1382 /***************************************************************************
1383  * Implementation of the wizard itself
1384  ***************************************************************************/
1385 wizHelloPage *page1;
1386 wizInputPage *page2 ;
1387 wizTranscodeCodecPage *tr_page1 ;
1388 wizStreamingMethodPage *st_page1;
1389 wizTranscodeExtraPage *tr_page2 ;
1390 wizStreamingExtraPage *st_page2;
1391 wizEncapPage *encap_page;
1392
1393 WizardDialog::WizardDialog(intf_thread_t *_p_intf, wxWindow *_p_parent,
1394                            char *psz_uri, int _i_from, int _i_to  ) :
1395 wxWizard( _p_parent, -1, wxU(_("Streaming/Transcoding Wizard")), wxNullBitmap, wxDefaultPosition)
1396 {
1397     /* Initializations */
1398     p_intf = _p_intf;
1399     SetPageSize(wxSize(400,420));
1400
1401     /* Initialize structure */
1402     i_action = 0;
1403     i_from = _i_from;
1404     i_to = _i_to;
1405     i_ttl = 1;
1406     vb = 0;
1407     ab = 0;
1408     acodec=NULL;
1409     vcodec=NULL;
1410
1411     page1 = new wizHelloPage(this);
1412     page2 = new wizInputPage(this, page1, p_intf);
1413
1414     if( psz_uri )
1415     {
1416         page2->SetUri( psz_uri );
1417     }
1418     if( i_from != 0 || i_to != 0 )
1419     {
1420         page2->SetPartial( i_from, i_to );
1421     }
1422
1423     encap_page = new wizEncapPage(this );
1424     tr_page1 = new wizTranscodeCodecPage(this, encap_page );
1425     st_page1 = new wizStreamingMethodPage( p_intf, this, encap_page);
1426
1427     tr_page2 = new wizTranscodeExtraPage(this, encap_page, NULL );
1428     st_page2 = new wizStreamingExtraPage(this, encap_page, NULL );
1429
1430     /* Page 1 -> 2 */
1431     page1->SetNext( page2 );
1432     /* 2->1 in constructor of 2 */
1433
1434     /* Page 2 -> 3 */
1435     page2->SetTranscodePage(tr_page1);
1436     page2->SetStreamingPage(st_page1);
1437     page2->SetPintf( p_intf );
1438     tr_page1->SetPrev(page2);
1439     st_page1->SetPrev(page2);
1440
1441     /* Page 3 -> 4 */
1442     encap_page->SetTranscodePage( tr_page2 );
1443     encap_page->SetStreamingPage( st_page2 );
1444     /* 3->4 in constructor of 3 */
1445 //    encap_page->SetPrev(tr_page1);
1446 }
1447
1448 WizardDialog::~WizardDialog()
1449 {
1450     Destroy();
1451     delete page1;
1452     delete page2;
1453     delete tr_page1;
1454     delete st_page1 ;
1455     delete st_page2;
1456     delete tr_page2;
1457     delete encap_page;
1458 }
1459
1460 void WizardDialog::SetMrl( const char *mrl )
1461 {
1462     this->mrl = strdup( mrl );
1463 }
1464
1465 void WizardDialog::SetTTL( int i_ttl )
1466 {
1467     this->i_ttl = i_ttl;
1468 }
1469
1470 void WizardDialog::SetSAP( bool b_enabled, const char *psz_text )
1471 {
1472     this->b_sap = b_enabled;
1473     if( b_enabled )
1474     {
1475         if( psz_text != NULL )
1476         {
1477             this->psz_sap_name = strdup( psz_text );
1478         }
1479         else
1480         {
1481             this->psz_sap_name = NULL;
1482         }
1483     }
1484 }
1485
1486 void WizardDialog::SetPartial( int i_from, int i_to )
1487 {
1488     this->i_from = i_from;
1489     this->i_to = i_to;
1490 }
1491
1492 void WizardDialog::SetTranscode( char const *vcodec, int vb,
1493                                  char const *acodec, int ab)
1494 {
1495     if( strcmp( vcodec, "dummy") )
1496     {
1497         this->vcodec= strdup(vcodec);
1498     }
1499     if( strcmp( acodec, "dummy" ) )
1500     {
1501         this->acodec = strdup(acodec);
1502     }
1503     this->vb = vb;
1504     this->ab = ab;
1505 }
1506
1507 void WizardDialog::SetStream( char const *method, char const *address )
1508 {
1509     this->method = strdup( method );
1510     this->address = strdup( address );
1511 }
1512
1513 void WizardDialog::SetTranscodeOut( wxString address )
1514 {
1515     char *psz_utf8 = wxFromLocale( address );
1516     this->address = strdup( psz_utf8 );
1517     wxLocaleFree( psz_utf8 );
1518 }
1519
1520 void WizardDialog::SetMux( char const *mux )
1521 {
1522     this->mux = strdup( mux );
1523 }
1524
1525 void WizardDialog::SetAction( int i_action )
1526 {
1527     this->i_action = i_action;
1528 }
1529
1530 int WizardDialog::GetAction()
1531 {
1532     return i_action;
1533 }
1534
1535 void WizardDialog::Run()
1536 {
1537     if( RunWizard(page1) )
1538     {
1539         char *psz_opt;
1540
1541         if( i_action == ACTION_TRANSCODE )
1542         {
1543             msg_Dbg( p_intf,"starting transcode of %s to file %s",
1544                                   mrl, address);
1545             msg_Dbg( p_intf,"using %s (%i kbps) / %s (%i kbps),encap %s",
1546                                 vcodec,vb,acodec,ab,mux);
1547             char *psz_transcode;
1548
1549             if( vcodec != NULL || acodec != NULL )
1550             {
1551                 int i_tr_size = 14;
1552                 if( vcodec != NULL )
1553                     i_tr_size += strlen( vcodec ) + 17;
1554                 if( acodec != NULL )
1555                     i_tr_size += strlen( acodec ) + 17;
1556
1557                 if( vb > 999999 )
1558                     vb = 999999;
1559                 else if( vb < 0 )
1560                     vb = 0;
1561
1562                 if( ab > 999999 )
1563                     ab = 999999;
1564                 else if( ab < 0 )
1565                     ab = 0;
1566
1567                 psz_transcode = (char *)malloc( i_tr_size * sizeof(char) );
1568
1569                 strcpy( psz_transcode, "transcode{" );
1570                 if( vcodec != NULL )
1571                 {
1572                     sprintf( psz_transcode + strlen( psz_transcode ),
1573                              "vcodec=%s,vb=%i%s", vcodec, vb,
1574                              ( acodec != NULL ) ? "," : "}:" );
1575                 }
1576                 if( acodec != NULL )
1577                 {
1578                     sprintf( psz_transcode + strlen( psz_transcode ),
1579                              "acodec=%s,ab=%i}:", acodec, ab );
1580                 }
1581             }
1582             else
1583                 psz_transcode = "";
1584
1585             asprintf( &psz_opt, ":sout=#%sstandard{mux=%s,dst=%s,"
1586                       "access=file}", psz_transcode, mux, address );
1587
1588             if( *psz_transcode )
1589                 free( psz_transcode );
1590         }
1591         else
1592         {
1593             char *psz_sap_option = NULL;
1594             bool v6;
1595
1596             msg_Dbg( p_intf, "starting stream of %s to %s using %s, encap %s",
1597                                mrl, address, method, mux );
1598             if( b_sap )
1599             {
1600                 if( psz_sap_name )
1601                 {
1602                     asprintf( &psz_sap_option,
1603                               ",sap,name=\"%s\"", psz_sap_name );
1604                 }
1605                 else
1606                     psz_sap_option = strdup( ",sap" );
1607
1608             }
1609
1610             /* Add brackets automatically for IPv6 if they are missing */
1611             v6 = ( address[0] != '[' ) && ( strchr( address, ':' ) != NULL );
1612             asprintf( &psz_opt,
1613                       ":sout=#standard{mux=%s,dst=%s%s%s,access=%s%s}",
1614                       mux, v6 ? "[" : "", address, v6 ? "]" : "", method,
1615                       psz_sap_option ?: "" );
1616             if( psz_sap_option ) free( psz_sap_option );
1617         }
1618
1619         playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_intf,
1620                             VLC_OBJECT_PLAYLIST, FIND_ANYWHERE);
1621         if( p_playlist )
1622         {
1623             input_item_t *p_input = input_ItemNew( p_playlist, mrl,
1624                                                    ITEM_NAME );
1625             input_ItemAddOption( p_input, psz_opt );
1626             if( i_from != 0)
1627             {
1628                 char psz_from[20];
1629                 snprintf( psz_from, 20, "start-time=%i", i_from);
1630                 input_ItemAddOption( p_input, psz_from );
1631             }
1632             if( i_to != 0)
1633             {
1634                 char psz_to[20];
1635                 snprintf( psz_to, 20, "stop-time=%i", i_to);
1636                 input_ItemAddOption( p_input, psz_to );
1637             }
1638
1639             char psz_ttl[20];
1640             snprintf( psz_ttl, 20, "ttl=%i",i_ttl );
1641             input_ItemAddOption( p_input, psz_ttl );
1642
1643             playlist_AddInput( p_playlist, p_input,
1644                                PLAYLIST_GO, PLAYLIST_END, VLC_TRUE );
1645             vlc_object_release(p_playlist);
1646         }
1647         else
1648         {
1649             wxMessageBox( wxU( NO_PLAYLIST ), wxU( ERROR_MSG ),
1650                           wxICON_WARNING | wxOK, this );
1651         }
1652     }
1653 }