Logo Search packages:      
Sourcecode: cadencii version File versions  Download package

void org::kbinani::cadencii::FormMain::applyLanguage (  ) [inline]

このコンポーネントの表示言語を、現在の言語設定に従って更新します。

Definition at line 4440 of file FormMain.cs.

References org::kbinani::cadencii::AppManager::isPlaying().

        {
            openXmlVsqDialog.clearChoosableFileFilter();
            try {
                openXmlVsqDialog.addFileFilter( _( "XML-VSQ Format(*.xvsq)|*.xvsq" ) );
                openXmlVsqDialog.addFileFilter( _( "All Files(*.*)|*.*" ) );
            } catch ( Exception ex ) {
                Logger.write( typeof( FormMain ) + ".applyLanguage; ex=" + ex + "\n" );
                openXmlVsqDialog.addFileFilter( "XML-VSQ Format(*.xvsq)|*.xvsq" );
                openXmlVsqDialog.addFileFilter( "All Files(*.*)|*.*" );
            }

            saveXmlVsqDialog.clearChoosableFileFilter();
            try {
                saveXmlVsqDialog.addFileFilter( _( "XML-VSQ Format(*.xvsq)|*.xvsq" ) );
                saveXmlVsqDialog.addFileFilter( _( "All Files(*.*)|*.*" ) );
            } catch ( Exception ex ) {
                Logger.write( typeof( FormMain ) + ".applyLanguage; ex=" + ex + "\n" );
                saveXmlVsqDialog.addFileFilter( "XML-VSQ Format(*.xvsq)|*.xvsq" );
                saveXmlVsqDialog.addFileFilter( "All Files(*.*)|*.*" );
            }

            openUstDialog.clearChoosableFileFilter();
            try {
                openUstDialog.addFileFilter( _( "UTAU Script Format(*.ust)|*.ust" ) );
                openUstDialog.addFileFilter( _( "All Files(*.*)|*.*" ) );
            } catch ( Exception ex ) {
                Logger.write( typeof( FormMain ) + ".applyLanguage; ex=" + ex + "\n" );
                openUstDialog.addFileFilter( "UTAU Script Format(*.ust)|*.ust" );
                openUstDialog.addFileFilter( "All Files(*.*)|*.*" );
            }

            openMidiDialog.clearChoosableFileFilter();
            try {
                openMidiDialog.addFileFilter( _( "MIDI Format(*.mid)|*.mid" ) );
                openMidiDialog.addFileFilter( _( "VSQ Format(*.vsq)|*.vsq" ) );
                openMidiDialog.addFileFilter( _( "All Files(*.*)|*.*" ) );
            } catch ( Exception ex ) {
                Logger.write( typeof( FormMain ) + ".applyLanguage; ex=" + ex + "\n" );
                openMidiDialog.addFileFilter( "MIDI Format(*.mid)|*.mid" );
                openMidiDialog.addFileFilter( "VSQ Format(*.vsq)|*.vsq" );
                openMidiDialog.addFileFilter( "All Files(*.*)|*.*" );
            }

            saveMidiDialog.clearChoosableFileFilter();
            try {
                saveMidiDialog.addFileFilter( _( "MIDI Format(*.mid)|*.mid" ) );
                saveMidiDialog.addFileFilter( _( "VSQ Format(*.vsq)|*.vsq" ) );
                saveMidiDialog.addFileFilter( _( "All Files(*.*)|*.*" ) );
            } catch ( Exception ex ) {
                Logger.write( typeof( FormMain ) + ".applyLanguage; ex=" + ex + "\n" );
                saveMidiDialog.addFileFilter( "MIDI Format(*.mid)|*.mid" );
                saveMidiDialog.addFileFilter( "VSQ Format(*.vsq)|*.vsq" );
                saveMidiDialog.addFileFilter( "All Files(*.*)|*.*" );
            }

            openWaveDialog.clearChoosableFileFilter();
            try {
                openWaveDialog.addFileFilter( _( "Wave File(*.wav)|*.wav" ) );
                openWaveDialog.addFileFilter( _( "All Files(*.*)|*.*" ) );
            } catch ( Exception ex ) {
                Logger.write( typeof( FormMain ) + ".applyLanguage; ex=" + ex + "\n" );
                openWaveDialog.addFileFilter( "Wave File(*.wav)|*.wav" );
                openWaveDialog.addFileFilter( "All Files(*.*)|*.*" );
            }

#if !JAVA
            stripLblGameCtrlMode.setToolTipText( _( "Game controler" ) );
#endif

#if JAVA
            updateGameControlerStatus( this, new EventArgs() );
#else
            this.Invoke( new BEventHandler( updateGameControlerStatus ) );
#endif

#if JAVA
            stripBtnPointer.setText( _( "Pointer" ) );
            stripBtnPointer.setToolTipText( _( "Pointer" ) );
            stripBtnPencil.setText( _( "Pencil" ) );
            stripBtnPencil.setToolTipText( _( "Pencil" ) );
            stripBtnLine.setText( _( "Line" ) );
            stripBtnLine.setToolTipText( _( "Line" ) );
            stripBtnEraser.setText( _( "Eraser" ) );
            stripBtnEraser.setToolTipText( _( "Eraser" ) );
            //stripBtnCurve.setText( _( "Curve" ) );
            stripBtnCurve.setToolTipText( _( "Curve" ) );
            //stripBtnGrid.setText( _( "Grid" ) );
            stripBtnGrid.setToolTipText( _( "Grid" ) );
            if ( AppManager.isPlaying() ) {
                stripBtnPlay.setText( _( "Stop" ) );
            } else {
                stripBtnPlay.setText( _( "Play" ) );
            }
#else
            stripBtnPointer.Text = _( "Pointer" );
            stripBtnPointer.ToolTipText = _( "Pointer" );
            stripBtnPencil.Text = _( "Pencil" );
            stripBtnPencil.ToolTipText = _( "Pencil" );
            stripBtnLine.Text = _( "Line" );
            stripBtnLine.ToolTipText = _( "Line" );
            stripBtnEraser.Text = _( "Eraser" );
            stripBtnEraser.ToolTipText = _( "Eraser" );
            stripBtnCurve.Text = _( "Curve" );
            stripBtnCurve.ToolTipText = _( "Curve" );
            stripBtnGrid.Text = _( "Grid" );
            stripBtnGrid.ToolTipText = _( "Grid" );
            if ( AppManager.isPlaying() ) {
                stripBtnPlay.Text = _( "Stop" );
            } else {
                stripBtnPlay.Text = _( "Play" );
            }
#endif

#if !JAVA
            stripBtnMoveTop.ToolTipText = _( "Move to beginning measure" );
            stripBtnMoveEnd.ToolTipText = _( "Move to end measure" );
            stripBtnForward.ToolTipText = _( "Move forward" );
            stripBtnRewind.ToolTipText = _( "Move backwared" );
            stripBtnLoop.ToolTipText = _( "Repeat" );
            stripBtnScroll.ToolTipText = _( "Auto scroll" );
#endif

            #region main menu
            menuFile.setText( _( "File" ) );
            menuFile.setMnemonic( KeyEvent.VK_F );
            menuFileNew.setText( _( "New" ) );
            menuFileNew.setMnemonic( KeyEvent.VK_N );
            menuFileOpen.setText( _( "Open" ) );
            menuFileOpen.setMnemonic( KeyEvent.VK_O );
            menuFileOpenVsq.setText( _( "Open VSQ/Vocaloid MIDI" ) );
            menuFileOpenVsq.setMnemonic( KeyEvent.VK_V );
            menuFileOpenUst.setText( _( "Open UTAU project file" ) );
            menuFileOpenUst.setMnemonic( KeyEvent.VK_U );
            menuFileSave.setText( _( "Save" ) );
            menuFileSave.setMnemonic( KeyEvent.VK_S );
            menuFileSaveNamed.setText( _( "Save as" ) );
            menuFileSaveNamed.setMnemonic( KeyEvent.VK_A );
            menuFileImport.setText( _( "Import" ) );
            menuFileImport.setMnemonic( KeyEvent.VK_I );
            menuFileImportVsq.setText( _( "VSQ / Vocaloid Midi" ) );
            menuFileExport.setText( _( "Export" ) );
            menuFileExport.setMnemonic( KeyEvent.VK_E );
            menuFileExportWave.setText( _( "WAVE" ) );
            menuFileExportParaWave.setText( _( "Serial numbered WAVEs" ) );
            menuFileExportUst.setText( _( "UTAU project file" ) );
            menuFileExportVxt.setText( _( "Metatext for vConnect" ) );
            menuFileRecent.setText( _( "Open Recent" ) );
            menuFileRecent.setMnemonic( KeyEvent.VK_R );
            menuFileRecentClear.setText( _( "Clear Menu" ) );
            menuFileQuit.setText( _( "Quit" ) );
            menuFileQuit.setMnemonic( KeyEvent.VK_Q );

            menuEdit.setText( _( "Edit" ) );
            menuEdit.setMnemonic( KeyEvent.VK_E );
            menuEditUndo.setText( _( "Undo" ) );
            menuEditUndo.setMnemonic( KeyEvent.VK_U );
            menuEditRedo.setText( _( "Redo" ) );
            menuEditRedo.setMnemonic( KeyEvent.VK_R );
            menuEditCut.setText( _( "Cut" ) );
            menuEditCut.setMnemonic( KeyEvent.VK_T );
            menuEditCopy.setText( _( "Copy" ) );
            menuEditCopy.setMnemonic( KeyEvent.VK_C );
            menuEditPaste.setText( _( "Paste" ) );
            menuEditPaste.setMnemonic( KeyEvent.VK_P );
            menuEditDelete.setText( _( "Delete" ) );
            menuEditDelete.setMnemonic( KeyEvent.VK_D );
            menuEditAutoNormalizeMode.setText( _( "Auto normalize mode" ) );
            menuEditAutoNormalizeMode.setMnemonic( KeyEvent.VK_N );
            menuEditSelectAll.setText( _( "Select All" ) );
            menuEditSelectAll.setMnemonic( KeyEvent.VK_A );
            menuEditSelectAllEvents.setText( _( "Select all events" ) );
            menuEditSelectAllEvents.setMnemonic( KeyEvent.VK_E );

            menuVisual.setText( _( "View" ) );
            menuVisual.setMnemonic( KeyEvent.VK_V );
            menuVisualControlTrack.setText( _( "Control track" ) );
            menuVisualControlTrack.setMnemonic( KeyEvent.VK_C );
            menuVisualMixer.setText( _( "Mixer" ) );
            menuVisualMixer.setMnemonic( KeyEvent.VK_X );
            menuVisualWaveform.setText( _( "Waveform" ) );
            menuVisualWaveform.setMnemonic( KeyEvent.VK_W );
            menuVisualProperty.setText( _( "Property window" ) );
            menuVisualOverview.setText( _( "Navigation" ) );
            menuVisualOverview.setMnemonic( KeyEvent.VK_V );
            menuVisualGridline.setText( _( "Grid line" ) );
            menuVisualGridline.setMnemonic( KeyEvent.VK_G );
            menuVisualStartMarker.setText( _( "Start marker" ) );
            menuVisualStartMarker.setMnemonic( KeyEvent.VK_S );
            menuVisualEndMarker.setText( _( "End marker" ) );
            menuVisualEndMarker.setMnemonic( KeyEvent.VK_E );
            menuVisualLyrics.setText( _( "Lyrics/Phoneme" ) );
            menuVisualLyrics.setMnemonic( KeyEvent.VK_L );
            menuVisualNoteProperty.setText( _( "Note expression/vibrato" ) );
            menuVisualNoteProperty.setMnemonic( KeyEvent.VK_N );
            menuVisualPitchLine.setText( _( "Pitch line" ) );
            menuVisualPitchLine.setMnemonic( KeyEvent.VK_P );
            menuVisualPluginUi.setText( _( "VSTi plugin UI" ) );
            menuVisualPluginUi.setMnemonic( KeyEvent.VK_U );
            menuVisualIconPalette.setText( _( "Icon palette" ) );
            menuVisualIconPalette.setMnemonic( KeyEvent.VK_I );

            menuJob.setText( _( "Job" ) );
            menuJob.setMnemonic( KeyEvent.VK_J );
            menuJobNormalize.setText( _( "Normalize notes" ) );
            menuJobNormalize.setMnemonic( KeyEvent.VK_N );
            menuJobInsertBar.setText( _( "Insert bars" ) );
            menuJobInsertBar.setMnemonic( KeyEvent.VK_I );
            menuJobDeleteBar.setText( _( "Delete bars" ) );
            menuJobDeleteBar.setMnemonic( KeyEvent.VK_D );
            menuJobRandomize.setText( _( "Randomize" ) );
            menuJobRandomize.setMnemonic( KeyEvent.VK_R );
            menuJobConnect.setText( _( "Connect notes" ) );
            menuJobConnect.setMnemonic( KeyEvent.VK_C );
            menuJobLyric.setText( _( "Insert lyrics" ) );
            menuJobLyric.setMnemonic( KeyEvent.VK_L );

            menuTrack.setText( _( "Track" ) );
            menuTrack.setMnemonic( KeyEvent.VK_T );
            menuTrackOn.setText( _( "Track on" ) );
            menuTrackOn.setMnemonic( KeyEvent.VK_K );
            menuTrackAdd.setText( _( "Add track" ) );
            menuTrackAdd.setMnemonic( KeyEvent.VK_A );
            menuTrackCopy.setText( _( "Copy track" ) );
            menuTrackCopy.setMnemonic( KeyEvent.VK_C );
            menuTrackChangeName.setText( _( "Rename track" ) );
            menuTrackDelete.setText( _( "Delete track" ) );
            menuTrackDelete.setMnemonic( KeyEvent.VK_D );
            menuTrackRenderCurrent.setText( _( "Render current track" ) );
            menuTrackRenderCurrent.setMnemonic( KeyEvent.VK_T );
            menuTrackRenderAll.setText( _( "Render all tracks" ) );
            menuTrackRenderAll.setMnemonic( KeyEvent.VK_S );
            menuTrackOverlay.setText( _( "Overlay" ) );
            menuTrackOverlay.setMnemonic( KeyEvent.VK_O );
            menuTrackRenderer.setText( _( "Renderer" ) );
            menuTrackRenderer.setMnemonic( KeyEvent.VK_R );
            menuTrackRendererVOCALOID1.setMnemonic( KeyEvent.VK_1 );
            menuTrackRendererVOCALOID2.setMnemonic( KeyEvent.VK_3 );
            menuTrackRendererUtau.setMnemonic( KeyEvent.VK_4 );
            menuTrackRendererVCNT.setMnemonic( KeyEvent.VK_5 );
            menuTrackRendererAquesTone.setMnemonic( KeyEvent.VK_6 );

            menuLyric.setText( _( "Lyrics" ) );
            menuLyric.setMnemonic( KeyEvent.VK_L );
            menuLyricExpressionProperty.setText( _( "Note expression property" ) );
            menuLyricExpressionProperty.setMnemonic( KeyEvent.VK_E );
            menuLyricVibratoProperty.setText( _( "Note vibrato property" ) );
            menuLyricVibratoProperty.setMnemonic( KeyEvent.VK_V );
            menuLyricApplyUtauParameters.setText( _( "Apply UTAU Parameters" ) );
            menuLyricApplyUtauParameters.setMnemonic( KeyEvent.VK_A );
            menuLyricPhonemeTransformation.setText( _( "Phoneme transformation" ) );
            menuLyricPhonemeTransformation.setMnemonic( KeyEvent.VK_T );
            menuLyricDictionary.setText( _( "User word dictionary" ) );
            menuLyricDictionary.setMnemonic( KeyEvent.VK_C );
            menuLyricCopyVibratoToPreset.setText( _( "Copy vibrato config to preset" ) );
            menuLyricCopyVibratoToPreset.setMnemonic( KeyEvent.VK_P );

            menuScript.setText( _( "Script" ) );
            menuScript.setMnemonic( KeyEvent.VK_C );
            menuScriptUpdate.setText( _( "Update script list" ) );
            menuScriptUpdate.setMnemonic( KeyEvent.VK_U );

            menuSetting.setText( _( "Setting" ) );
            menuSetting.setMnemonic( KeyEvent.VK_S );
            menuSettingPreference.setText( _( "Preference" ) );
            menuSettingPreference.setMnemonic( KeyEvent.VK_P );
            menuSettingGameControler.setText( _( "Game controler" ) );
            menuSettingGameControler.setMnemonic( KeyEvent.VK_G );
            menuSettingGameControlerLoad.setText( _( "Load" ) );
            menuSettingGameControlerLoad.setMnemonic( KeyEvent.VK_L );
            menuSettingGameControlerRemove.setText( _( "Remove" ) );
            menuSettingGameControlerRemove.setMnemonic( KeyEvent.VK_R );
            menuSettingGameControlerSetting.setText( _( "Setting" ) );
            menuSettingGameControlerSetting.setMnemonic( KeyEvent.VK_S );
            menuSettingSequence.setText( _( "Sequence config" ) );
            menuSettingSequence.setMnemonic( KeyEvent.VK_S );
            menuSettingShortcut.setText( _( "Shortcut key" ) );
            menuSettingShortcut.setMnemonic( KeyEvent.VK_K );
            menuSettingDefaultSingerStyle.setText( _( "Singing style defaults" ) );
            menuSettingDefaultSingerStyle.setMnemonic( KeyEvent.VK_D );
            menuSettingPositionQuantize.setText( _( "Quantize" ) );
            menuSettingPositionQuantize.setMnemonic( KeyEvent.VK_Q );
            menuSettingPositionQuantizeOff.setText( _( "Off" ) );
            menuSettingPositionQuantizeTriplet.setText( _( "Triplet" ) );
            //menuSettingSingerProperty.setText( _( "Singer Properties" ) );
            //menuSettingSingerProperty.setMnemonic( KeyEvent.VK_S );
            menuSettingPaletteTool.setText( _( "Palette Tool" ) );
            menuSettingPaletteTool.setMnemonic( KeyEvent.VK_T );
            menuSettingVibratoPreset.setText( _( "Vibrato preset" ) );
            menuSettingVibratoPreset.setMnemonic( KeyEvent.VK_V );

#if JAVA
            menuWindow.setText( _( "Window" ) );
            menuWindowMinimize.setText( _( "Minimize" ) );
#endif

            menuHelp.setText( _( "Help" ) );
            menuHelp.setMnemonic( KeyEvent.VK_H );
            menuHelpLog.setText( _( "Log" ) );
            menuHelpLog.setMnemonic( KeyEvent.VK_L );
            menuHelpLogSwitch.setText( Logger.isEnabled() ? _( "Disable" ) : _( "Enable" ) );
            menuHelpLogSwitch.setMnemonic( KeyEvent.VK_L );
            menuHelpLogOpen.setText( _( "Open" ) );
            menuHelpLogOpen.setMnemonic( KeyEvent.VK_O );
            menuHelpAbout.setText( _( "About Cadencii" ) );
            menuHelpAbout.setMnemonic( KeyEvent.VK_A );
            menuHelpManual.setText( _( "Manual" ) + " (PDF)" );

            menuHiddenCopy.setText( _( "Copy" ) );
            menuHiddenCut.setText( _( "Cut" ) );
            menuHiddenEditFlipToolPointerEraser.setText( _( "Chagne tool pointer / eraser" ) );
            menuHiddenEditFlipToolPointerPencil.setText( _( "Change tool pointer / pencil" ) );
            menuHiddenEditLyric.setText( _( "Start lyric input" ) );
            menuHiddenGoToEndMarker.setText( _( "GoTo end marker" ) );
            menuHiddenGoToStartMarker.setText( _( "Goto start marker" ) );
            menuHiddenLengthen.setText( _( "Lengthen" ) );
            menuHiddenMoveDown.setText( _( "Move down" ) );
            menuHiddenMoveLeft.setText( _( "Move left" ) );
            menuHiddenMoveRight.setText( _( "Move right" ) );
            menuHiddenMoveUp.setText( _( "Move up" ) );
            menuHiddenPaste.setText( _( "Paste" ) );
            menuHiddenPlayFromStartMarker.setText( _( "Play from start marker" ) );
            menuHiddenSelectBackward.setText( _( "Select backward" ) );
            menuHiddenSelectForward.setText( _( "Select forward" ) );
            menuHiddenShorten.setText( _( "Shorten" ) );
            menuHiddenTrackBack.setText( _( "Previous track" ) );
            menuHiddenTrackNext.setText( _( "Next track" ) );
            menuHiddenVisualBackwardParameter.setText( _( "Previous control curve" ) );
            menuHiddenVisualForwardParameter.setText( _( "Next control curve" ) );
            menuHiddenFlipCurveOnPianorollMode.setText( _( "Change pitch drawing mode" ) );
            #endregion

            #region cMenuPiano
            cMenuPianoPointer.setText( _( "Arrow" ) );
            cMenuPianoPointer.setMnemonic( KeyEvent.VK_A );
            cMenuPianoPencil.setText( _( "Pencil" ) );
            cMenuPianoPencil.setMnemonic( KeyEvent.VK_W );
            cMenuPianoEraser.setText( _( "Eraser" ) );
            cMenuPianoEraser.setMnemonic( KeyEvent.VK_E );
            cMenuPianoPaletteTool.setText( _( "Palette Tool" ) );

            cMenuPianoCurve.setText( _( "Curve" ) );
            cMenuPianoCurve.setMnemonic( KeyEvent.VK_V );

            cMenuPianoFixed.setText( _( "Note Fixed Length" ) );
            cMenuPianoFixed.setMnemonic( KeyEvent.VK_N );
            cMenuPianoFixedTriplet.setText( _( "Triplet" ) );
            cMenuPianoFixedOff.setText( _( "Off" ) );
            cMenuPianoFixedDotted.setText( _( "Dot" ) );
            cMenuPianoQuantize.setText( _( "Quantize" ) );
            cMenuPianoQuantize.setMnemonic( KeyEvent.VK_Q );
            cMenuPianoQuantizeTriplet.setText( _( "Triplet" ) );
            cMenuPianoQuantizeOff.setText( _( "Off" ) );
            cMenuPianoGrid.setText( _( "Show/Hide Grid Line" ) );
            cMenuPianoGrid.setMnemonic( KeyEvent.VK_S );

            cMenuPianoUndo.setText( _( "Undo" ) );
            cMenuPianoUndo.setMnemonic( KeyEvent.VK_U );
            cMenuPianoRedo.setText( _( "Redo" ) );
            cMenuPianoRedo.setMnemonic( KeyEvent.VK_R );

            cMenuPianoCut.setText( _( "Cut" ) );
            cMenuPianoCut.setMnemonic( KeyEvent.VK_T );
            cMenuPianoPaste.setText( _( "Paste" ) );
            cMenuPianoPaste.setMnemonic( KeyEvent.VK_P );
            cMenuPianoCopy.setText( _( "Copy" ) );
            cMenuPianoCopy.setMnemonic( KeyEvent.VK_C );
            cMenuPianoDelete.setText( _( "Delete" ) );
            cMenuPianoDelete.setMnemonic( KeyEvent.VK_D );

            cMenuPianoSelectAll.setText( _( "Select All" ) );
            cMenuPianoSelectAll.setMnemonic( KeyEvent.VK_A );
            cMenuPianoSelectAllEvents.setText( _( "Select All Events" ) );
            cMenuPianoSelectAllEvents.setMnemonic( KeyEvent.VK_E );

            cMenuPianoExpressionProperty.setText( _( "Note Expression Property" ) );
            cMenuPianoExpressionProperty.setMnemonic( KeyEvent.VK_P );
            cMenuPianoVibratoProperty.setText( _( "Note Vibrato Property" ) );
            cMenuPianoImportLyric.setText( _( "Insert Lyrics" ) );
            cMenuPianoImportLyric.setMnemonic( KeyEvent.VK_P );
            #endregion

            #region cMenuTrackTab
            cMenuTrackTabTrackOn.setText( _( "Track On" ) );
            cMenuTrackTabTrackOn.setMnemonic( KeyEvent.VK_K );
            cMenuTrackTabAdd.setText( _( "Add Track" ) );
            cMenuTrackTabAdd.setMnemonic( KeyEvent.VK_A );
            cMenuTrackTabCopy.setText( _( "Copy Track" ) );
            cMenuTrackTabCopy.setMnemonic( KeyEvent.VK_C );
            cMenuTrackTabChangeName.setText( _( "Rename Track" ) );
            cMenuTrackTabDelete.setText( _( "Delete Track" ) );
            cMenuTrackTabDelete.setMnemonic( KeyEvent.VK_D );

            cMenuTrackTabRenderCurrent.setText( _( "Render Current Track" ) );
            cMenuTrackTabRenderCurrent.setMnemonic( KeyEvent.VK_T );
            cMenuTrackTabRenderAll.setText( _( "Render All Tracks" ) );
            cMenuTrackTabRenderAll.setMnemonic( KeyEvent.VK_S );
            cMenuTrackTabOverlay.setText( _( "Overlay" ) );
            cMenuTrackTabOverlay.setMnemonic( KeyEvent.VK_O );
            cMenuTrackTabRenderer.setText( _( "Renderer" ) );
            cMenuTrackTabRenderer.setMnemonic( KeyEvent.VK_R );
            #endregion

            #region cMenuTrackSelector
            cMenuTrackSelectorPointer.setText( _( "Arrow" ) );
            cMenuTrackSelectorPointer.setMnemonic( KeyEvent.VK_A );
            cMenuTrackSelectorPencil.setText( _( "Pencil" ) );
            cMenuTrackSelectorPencil.setMnemonic( KeyEvent.VK_W );
            cMenuTrackSelectorLine.setText( _( "Line" ) );
            cMenuTrackSelectorLine.setMnemonic( KeyEvent.VK_L );
            cMenuTrackSelectorEraser.setText( _( "Eraser" ) );
            cMenuTrackSelectorEraser.setMnemonic( KeyEvent.VK_E );
            cMenuTrackSelectorPaletteTool.setText( _( "Palette Tool" ) );

            cMenuTrackSelectorCurve.setText( _( "Curve" ) );
            cMenuTrackSelectorCurve.setMnemonic( KeyEvent.VK_V );

            cMenuTrackSelectorUndo.setText( _( "Undo" ) );
            cMenuTrackSelectorUndo.setMnemonic( KeyEvent.VK_U );
            cMenuTrackSelectorRedo.setText( _( "Redo" ) );
            cMenuTrackSelectorRedo.setMnemonic( KeyEvent.VK_R );

            cMenuTrackSelectorCut.setText( _( "Cut" ) );
            cMenuTrackSelectorCut.setMnemonic( KeyEvent.VK_T );
            cMenuTrackSelectorCopy.setText( _( "Copy" ) );
            cMenuTrackSelectorCopy.setMnemonic( KeyEvent.VK_C );
            cMenuTrackSelectorPaste.setText( _( "Paste" ) );
            cMenuTrackSelectorPaste.setMnemonic( KeyEvent.VK_P );
            cMenuTrackSelectorDelete.setText( _( "Delete" ) );
            cMenuTrackSelectorDelete.setMnemonic( KeyEvent.VK_D );
            cMenuTrackSelectorDeleteBezier.setText( _( "Delete Bezier Point" ) );
            cMenuTrackSelectorDeleteBezier.setMnemonic( KeyEvent.VK_B );

            cMenuTrackSelectorSelectAll.setText( _( "Select All Events" ) );
            cMenuTrackSelectorSelectAll.setMnemonic( KeyEvent.VK_E );
            #endregion

            #region cMenuPositionIndicator
            cMenuPositionIndicatorStartMarker.setText( _( "Set start marker" ) );
            cMenuPositionIndicatorEndMarker.setText( _( "Set end marker" ) );
            #endregion

#if !JAVA
            stripLblGameCtrlMode.setToolTipText( _( "Game Controler" ) );
#endif

            // Palette Tool
#if DEBUG
            AppManager.debugWriteLine( "FormMain#applyLanguage; Messaging.Language=" + Messaging.getLanguage() );
#endif
#if ENABLE_SCRIPT
            int count = toolBarTool.Buttons.Count;// toolStripTool.getComponentCount();
            for ( int i = 0; i < count; i++ ) {
                Object tsi = toolBarTool.Buttons[i];// toolStripTool.getComponentAtIndex( i );
                if ( tsi is System.Windows.Forms.ToolBarButton ) {
                    System.Windows.Forms.ToolBarButton tsb = (System.Windows.Forms.ToolBarButton)tsi;
                    if ( tsb.Style == System.Windows.Forms.ToolBarButtonStyle.ToggleButton && tsb.Tag != null && tsb.Tag is String ) {
                        String id = (String)tsb.Tag;
                        if ( PaletteToolServer.loadedTools.containsKey( id ) ) {
                            IPaletteTool ipt = (IPaletteTool)PaletteToolServer.loadedTools.get( id );
                            tsb.Text = ipt.getName( Messaging.getLanguage() );
                            tsb.ToolTipText = ipt.getDescription( Messaging.getLanguage() );
                        }
                    }
                }
            }

            foreach ( MenuElement tsi in cMenuPianoPaletteTool.getSubElements() ) {
                if ( tsi is BMenuItem ) {
                    BMenuItem tsmi = (BMenuItem)tsi;
                    if ( tsmi.getTag() != null && tsmi.getTag() is String ) {
                        String id = (String)tsmi.getTag();
                        if ( PaletteToolServer.loadedTools.containsKey( id ) ) {
                            IPaletteTool ipt = (IPaletteTool)PaletteToolServer.loadedTools.get( id );
                            tsmi.setText( ipt.getName( Messaging.getLanguage() ) );
                            tsmi.setToolTipText( ipt.getDescription( Messaging.getLanguage() ) );
                        }
                    }
                }
            }

            foreach ( MenuElement tsi in cMenuTrackSelectorPaletteTool.getSubElements() ) {
                if ( tsi is BMenuItem ) {
                    BMenuItem tsmi = (BMenuItem)tsi;
                    if ( tsmi.getTag() != null && tsmi.getTag() is String ) {
                        String id = (String)tsmi.getTag();
                        if ( PaletteToolServer.loadedTools.containsKey( id ) ) {
                            IPaletteTool ipt = (IPaletteTool)PaletteToolServer.loadedTools.get( id );
                            tsmi.setText( ipt.getName( Messaging.getLanguage() ) );
                            tsmi.setToolTipText( ipt.getDescription( Messaging.getLanguage() ) );
                        }
                    }
                }
            }

            foreach ( MenuElement tsi in menuSettingPaletteTool.getSubElements() ) {
                if ( tsi is BMenuItem ) {
                    BMenuItem tsmi = (BMenuItem)tsi;
                    if ( tsmi.getTag() != null && tsmi.getTag() is String ) {
                        String id = (String)tsmi.getTag();
                        if ( PaletteToolServer.loadedTools.containsKey( id ) ) {
                            IPaletteTool ipt = (IPaletteTool)PaletteToolServer.loadedTools.get( id );
                            tsmi.setText( ipt.getName( Messaging.getLanguage() ) );
                        }
                    }
                }
            }

            for ( Iterator<String> itr = PaletteToolServer.loadedTools.keySet().iterator(); itr.hasNext(); ) {
                String id = (String)itr.next();
                IPaletteTool ipt = (IPaletteTool)PaletteToolServer.loadedTools.get( id );
                ipt.applyLanguage( Messaging.getLanguage() );
            }
#endif
        }

Here is the call graph for this function:


Generated by  Doxygen 1.6.0   Back to index