src/GnomeSubtitles/Ui/Menus.cs

   1 /*
   2  * This file is part of Gnome Subtitles.
   3  * Copyright (C) 2006-2010 Pedro Castro
   4  *
   5  * Gnome Subtitles is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * Gnome Subtitles is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 using GnomeSubtitles.Core;
  21 using GnomeSubtitles.Core.Command;
  22 using Gtk;
  23 using Mono.Unix;
  24 using SubLib.Core.Domain;
  25 using System;
  26 using System.Globalization;
  27
  28 namespace GnomeSubtitles.Ui {
  29
  30 public class Menus {
  31
  32         /* Constant strings */
  33         private string videoTagText = Catalog.GetString("Video");
  34
  35         /* Stored values */
  36         private bool viewLineLengthsEnabled = false;
  37
  38         public Menus () {
  39                 SetToolbarHomogeneity(); //TODO needed until homogeneity definition in glade starts working
  40                 SetDocumentSensitivity(false);
  41                 SetBlankActivity();
  42
  43                 Base.InitFinished += OnBaseInitFinished;
  44         }
  45
  46
  47         /* Public properties */
  48
  49         public float TimingsInputFrameRateActive {
  50                 get {
  51                         Menu menu = Base.GetWidget(WidgetNames.TimingsInputFrameRateMenu) as Menu;
  52                         foreach (RadioMenuItem menuItem in menu.Children) {
  53                                 if (menuItem.Active) {
  54                                         return FrameRateFromMenuItem((menuItem.Child as Label).Text);
  55                                 }
  56                         }
  57                         return -1;
  58                 }
  59         }
  60
  61         public bool ViewLineLengthsEnabled {
  62                 get { return viewLineLengthsEnabled; }
  63         }
  64
  65
  66         /* Public methods */
  67
  68         public void SetCutCopySensitivity (bool sensitivity) {
  69                 SetSensitivity(WidgetNames.EditCut, sensitivity);
  70                 SetSensitivity(WidgetNames.EditCopy, sensitivity);
  71                 SetSensitivity(WidgetNames.CutButton, sensitivity);
  72                 SetSensitivity(WidgetNames.CopyButton, sensitivity);
  73         }
  74
  75         public void SetPasteSensitivity (bool sensitivity) {
  76                 SetSensitivity(WidgetNames.EditPaste, sensitivity);
  77                 SetSensitivity(WidgetNames.PasteButton, sensitivity);
  78         }
  79
  80         public void UpdateActiveInputFrameRateMenuItem (bool toggleHandlers) {
  81                 float inputFrameRate = Base.Document.Subtitles.Properties.OriginalFrameRate;
  82                 if (toggleHandlers)
  83                         SetCheckMenuItemActivity(InputFrameRateMenuItem(inputFrameRate), true, OnTimingsInputFrameRateToggled);
  84                 else
  85                         SetCheckMenuItemActivity(InputFrameRateMenuItem(inputFrameRate), true);
  86         }
  87
  88         /* Note: this method makes the assumption that the OnTimingsVideoFrameRateToggled event handler is connected to the
  89            menu item, as it is disconnected and then connected again after changing the active menu item. */
  90         public void UpdateActiveVideoFrameRateMenuItem () {
  91                 float videoFrameRate = Base.Document.Subtitles.Properties.CurrentFrameRate;
  92                 SetCheckMenuItemActivity(VideoFrameRateMenuItem(videoFrameRate), true, OnTimingsVideoFrameRateToggled);
  93         }
  94
  95         public void EnableFindNextPrevious () {
  96                 SetSensitivity(WidgetNames.SearchFindNext, true);
  97                 SetSensitivity(WidgetNames.SearchFindPrevious, true);
  98         }
  99
 100         public void AddFrameRateVideoTag (float frameRate) {
 101                 if (frameRate <= 0)
 102                         return;
 103
 104                 string menuItemName = FrameRateToMenuItem(frameRate, "Video");
 105                 string menuItemText = GetMenuItemText(menuItemName);
 106
 107                 menuItemText += " (" + videoTagText + ")";
 108                 SetMenuItemText(menuItemName, menuItemText);
 109         }
 110
 111         public void RemoveFrameRateVideoTag () {
 112                 Menu menu = Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu;
 113                 foreach (Widget child in menu.Children) {
 114                         if (!(child is MenuItem))
 115                                 continue;
 116
 117                         MenuItem menuItem = child as MenuItem;
 118                         string text = GetMenuItemText(menuItem);
 119                         string videoTagSuffix = GetVideoTagSuffix();
 120
 121                         int tagIndex = text.LastIndexOf(videoTagSuffix);
 122                         if (tagIndex > 0) {
 123                                 text = text.Substring(0, tagIndex);
 124                                 SetMenuItemText(menuItem, text);
 125                         }
 126                 }
 127         }
 128
 129
 130         /* Private members */
 131
 132         /// <summary>Sets the sensitivity depending on 1 or more selected subtitles.</summary>
 133         /// <param name="sensitivity">Whether the items are set sensitive.</param>
 134         private void SetNonZeroSelectionDependentSensitivity (bool sensitivity) {
 135                 SetStylesSensitivity(sensitivity);
 136                 SetSensitivity(WidgetNames.EditDeleteSubtitles, sensitivity);
 137                 SetSensitivity(WidgetNames.DeleteSubtitlesButton, sensitivity);
 138         }
 139
 140         /// <summary>Sets the sensitivity depending on exactly 1 selected subtitle.</summary>
 141         /// <param name="sensitivity">Whether the items are set sensitive.</param>
 142         private void SetOneSelectionDependentSensitivity (bool sensitivity) {
 143                 SetVideoSelectionDependentSensitivity(sensitivity);
 144         }
 145
 146         private void SetSubtitleCountDependentSensitivity (int count) {
 147                 if (count == 0) {
 148                         SetSensitivity(WidgetNames.TimingsAdjust, false);
 149                         SetSensitivity(WidgetNames.TimingsShift, false);
 150                 }
 151                 else if (count == 1) {
 152                         SetSensitivity(WidgetNames.TimingsAdjust, false);
 153                         SetSensitivity(WidgetNames.TimingsShift, true);
 154                 }
 155                 else {
 156                         SetSensitivity(WidgetNames.TimingsAdjust, true);
 157                         SetSensitivity(WidgetNames.TimingsShift, true);
 158                 }
 159         }
 160
 161         private void SetBlankActivity () {
 162                 SetCheckMenuItemActivity(WidgetNames.ToolsAutocheckSpelling, Base.SpellLanguages.Enabled);
 163
 164                 /* Set View Line Lengths */
 165                 this.viewLineLengthsEnabled = Base.Config.PrefsViewLineLengths;
 166                 SetCheckMenuItemActivity(WidgetNames.ViewLineLengths, this.viewLineLengthsEnabled);
 167         }
 168
 169         private void SetViewVideoActivity (bool activity) {
 170                 SetCheckMenuItemActivity(WidgetNames.ViewVideo, activity);
 171         }
 172
 173         private void SetDocumentSensitivity (bool documentLoaded) {
 174                 /* Set Sensitivity that is equal to the document loaded status */
 175
 176                 /* File Menu */
 177                 SetSensitivity(WidgetNames.FileSave, documentLoaded);
 178                 SetSensitivity(WidgetNames.FileSaveAs, documentLoaded);
 179                 SetSensitivity(WidgetNames.FileHeaders, documentLoaded);
 180                 SetSensitivity(WidgetNames.FileProperties, documentLoaded);
 181                 SetSensitivity(WidgetNames.FileTranslationNew, documentLoaded);
 182                 SetSensitivity(WidgetNames.FileTranslationOpen, documentLoaded);
 183                 SetSensitivity(WidgetNames.FileClose, documentLoaded);
 184                 /* Edit Menu */
 185                 SetMenuSensitivity(WidgetNames.EditInsertSubtitleMenu, documentLoaded);
 186                 /* View Menu */
 187                 SetSensitivity(WidgetNames.ViewTimes, documentLoaded); //TODO always visible
 188                 SetSensitivity(WidgetNames.ViewFrames, documentLoaded); //TODO always visible
 189                 SetViewVideoSubtitlesSensitivity();
 190                 /* Search Menu */
 191                 SetSensitivity(WidgetNames.SearchFind, documentLoaded);
 192                 SetSensitivity(WidgetNames.SearchReplace, documentLoaded);
 193                 /* Timings Menu */
 194                 SetSensitivity(WidgetNames.TimingsSynchronize, documentLoaded);
 195                 /* Video Menu */
 196                 SetVideoDocumentLoadedSensitivity(documentLoaded);
 197                 /* Tools Menu */
 198                 SetToolsAutocheckSpellingSensitivity(documentLoaded);
 199                 SetSensitivity(WidgetNames.ToolsSetTextLanguage, documentLoaded);
 200                 /* Toolbar */
 201                 SetSensitivity(WidgetNames.SaveButton, documentLoaded);
 202                 SetSensitivity(WidgetNames.InsertSubtitleButton, documentLoaded);
 203
 204                 /* Set sensitivity that only applies when the document is not loaded */
 205
 206                 if (!documentLoaded) {
 207                         /* Edit menu */
 208                         SetSensitivity(WidgetNames.EditDeleteSubtitles, false);
 209                         SetSensitivity(WidgetNames.EditUndo, false);
 210                         SetSensitivity(WidgetNames.EditRedo, false);
 211                         SetSensitivity(WidgetNames.EditCut, false);
 212                         SetSensitivity(WidgetNames.EditCopy, false);
 213                         SetSensitivity(WidgetNames.EditPaste, false);
 214                         /* Search menu */
 215                         SetSensitivity(WidgetNames.SearchFindNext, false);
 216                         SetSensitivity(WidgetNames.SearchFindPrevious, false);
 217                         /* Timings Menu */
 218                         SetSensitivity(WidgetNames.TimingsAdjust, false);
 219                         SetSensitivity(WidgetNames.TimingsShift, false);
 220                         /* Toolbar */
 221                         SetSensitivity(WidgetNames.DeleteSubtitlesButton, false);
 222                         SetSensitivity(WidgetNames.UndoButton, false);
 223                         SetSensitivity(WidgetNames.RedoButton, false);
 224                         SetSensitivity(WidgetNames.CutButton, false);
 225                         SetSensitivity(WidgetNames.CopyButton, false);
 226                         SetSensitivity(WidgetNames.PasteButton, false);
 227                         /* Common for Format Menu and Toolbar */
 228                         SetStylesSensitivity(false);
 229                 }
 230         }
 231
 232         private void SetTranslationSensitivity (bool sensitivity) {
 233                 SetSensitivity(WidgetNames.FileTranslationSave, sensitivity);
 234                 SetSensitivity(WidgetNames.FileTranslationSaveAs, sensitivity);
 235                 SetSensitivity(WidgetNames.FileTranslationClose, sensitivity);
 236                 SetSensitivity(WidgetNames.ToolsSetTranslationLanguage, sensitivity);
 237             SetSensitivity(WidgetNames.TranslatorLeft, sensitivity);
 238                 SetSensitivity(WidgetNames.TranslatorRight, sensitivity);
 239                 SetViewVideoSubtitlesSensitivity();
 240         }
 241
 242         private void SetToolsAutocheckSpellingSensitivity (bool sensitivity) {
 243                 SetSensitivity(WidgetNames.ToolsAutocheckSpelling, sensitivity);
 244         }
 245
 246         private void SetFrameRateMenus (bool documentLoaded) {
 247                 if (documentLoaded) {
 248                         if (Base.TimingMode == TimingMode.Frames) {
 249                                 UpdateActiveInputFrameRateMenuItem(false);
 250                                 SetMenuSensitivity(WidgetNames.TimingsInputFrameRateMenu, true);
 251                                 SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsInputFrameRateMenu) as Menu, true, OnTimingsInputFrameRateToggled);
 252
 253                                 SetMenuSensitivity(WidgetNames.TimingsVideoFrameRateMenu, true);
 254                                 SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu, true, OnTimingsVideoFrameRateToggled);
 255                                 UpdateActiveVideoFrameRateMenuItem();
 256                         }
 257                         else {
 258                                 UpdateActiveInputFrameRateMenuItem(false);
 259                                 SetMenuSensitivity(WidgetNames.TimingsInputFrameRateMenu, false);
 260
 261                                 SetMenuSensitivity(WidgetNames.TimingsVideoFrameRateMenu, true);
 262                                 SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu, true, OnTimingsVideoFrameRateToggled);
 263                                 UpdateActiveVideoFrameRateMenuItem();
 264                         }
 265                 }
 266                 else {
 267                         SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsInputFrameRateMenu) as Menu, false, OnTimingsInputFrameRateToggled);
 268                         SetMenuSensitivity(WidgetNames.TimingsInputFrameRateMenu, true);
 269                         SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu, false, OnTimingsVideoFrameRateToggled);
 270                         SetMenuSensitivity(WidgetNames.TimingsVideoFrameRateMenu, false);
 271                 }
 272         }
 273
 274         private void SetStylesActivity (bool bold, bool italic, bool underline) {
 275                 SetCheckMenuItemActivity(WidgetNames.EditFormatBold, bold, Base.Handlers.OnEditFormatBold);
 276                 SetCheckMenuItemActivity(WidgetNames.EditFormatItalic, italic, Base.Handlers.OnEditFormatItalic);
 277                 SetCheckMenuItemActivity(WidgetNames.EditFormatUnderline, underline, Base.Handlers.OnEditFormatUnderline);
 278                 SetToggleToolButtonActivity(WidgetNames.BoldButton, bold, Base.Handlers.OnEditFormatBold);
 279                 SetToggleToolButtonActivity(WidgetNames.ItalicButton, italic, Base.Handlers.OnEditFormatItalic);
 280                 SetToggleToolButtonActivity(WidgetNames.UnderlineButton, underline, Base.Handlers.OnEditFormatUnderline);
 281         }
 282
 283         private void SetActiveTimingMode (TimingMode mode) {
 284                 if (mode == TimingMode.Times)
 285                         SetCheckMenuItemActivity(WidgetNames.ViewTimes, true);
 286                 else
 287                         SetCheckMenuItemActivity(WidgetNames.ViewFrames, true);
 288         }
 289
 290         private void SetViewVideoSubtitlesActivity (bool isTextActive) {
 291                 if (isTextActive)
 292                         SetCheckMenuItemActivity(WidgetNames.ViewVideoSubtitlesText, true);
 293                 else
 294                         SetCheckMenuItemActivity(WidgetNames.ViewVideoSubtitlesTranslation, true);
 295         }
 296
 297         private void SetVideoSensitivity (bool sensitivity) {
 298                 SetSensitivity(WidgetNames.VideoClose, sensitivity);
 299                 SetSensitivity(WidgetNames.VideoPlayPause, sensitivity);
 300                 SetSensitivity(WidgetNames.VideoRewind, sensitivity);
 301                 SetSensitivity(WidgetNames.VideoForward, sensitivity);
 302                 SetSensitivity(WidgetNames.VideoSeekTo, sensitivity);
 303                 SetVideoDocumentLoadedSensitivity(Base.IsDocumentLoaded);
 304
 305                 /* Set video menu dependent sensitivity if there is 1 selected subtitle. */
 306                 if ((Core.Base.Ui.View.Selection.Count == 1) && sensitivity)
 307                         SetVideoSelectionDependentSensitivity(true);
 308                 else
 309                         SetVideoSelectionDependentSensitivity(false);
 310         }
 311
 312         private void SetStylesSensitivity (bool sensitivity) {
 313                 if (Base.GetWidget(WidgetNames.EditFormatBold).Sensitive != sensitivity) {
 314                         SetSensitivity(WidgetNames.EditFormatBold, sensitivity);
 315                         SetSensitivity(WidgetNames.EditFormatItalic, sensitivity);
 316                         SetSensitivity(WidgetNames.EditFormatUnderline, sensitivity);
 317                         SetSensitivity(WidgetNames.BoldButton, sensitivity);
 318                         SetSensitivity(WidgetNames.ItalicButton, sensitivity);
 319                         SetSensitivity(WidgetNames.UnderlineButton, sensitivity);
 320                 }
 321         }
 322
 323         /// <summary>Set the video selection dependent menu items.</summary>
 324         /// <param name="sensitivity">Whether to set the menu items sensitive.</param>
 325         /// <remarks>The menu items are only set sensitive if the video is loaded.</remarks>
 326         private void SetVideoSelectionDependentSensitivity (bool sensitivity) {
 327                 if (Core.Base.Ui.Video.IsLoaded && sensitivity) {//TODO improve this
 328                         SetSensitivity(WidgetNames.VideoSeekToSelection, true);
 329                         SetSensitivity(WidgetNames.VideoSetSubtitleStart, true);
 330                         SetSensitivity(WidgetNames.VideoSetSubtitleEnd, true);
 331                 }
 332                 else {
 333                         SetSensitivity(WidgetNames.VideoSeekToSelection, false);
 334                         SetSensitivity(WidgetNames.VideoSetSubtitleStart, false);
 335                         SetSensitivity(WidgetNames.VideoSetSubtitleEnd, false);
 336                 }
 337         }
 338
 339         private void SetViewVideoSubtitlesSensitivity () {
 340                 bool isVideoLoaded = (Base.Ui != null) && Base.Ui.Video.IsLoaded;
 341                 bool textSensitivity = isVideoLoaded && Base.IsDocumentLoaded;
 342                 bool translationSensitivity = isVideoLoaded && textSensitivity && Base.Document.IsTranslationLoaded;
 343                 SetViewVideoSubtitlesSensitivity(textSensitivity, translationSensitivity);
 344         }
 345
 346         private void SetViewVideoSubtitlesSensitivity (bool textSensitivity, bool translationSensitivity) {
 347                 SetSensitivity(WidgetNames.ViewVideoSubtitlesText, textSensitivity);
 348                 SetSensitivity(WidgetNames.ViewVideoSubtitlesTranslation, translationSensitivity);
 349         }
 350
 351         private void SetVideoDocumentLoadedSensitivity (bool isDocumentLoaded) {
 352                 bool sensitivity = isDocumentLoaded && (Base.Ui != null) && Base.Ui.Video.IsLoaded;
 353                 SetSensitivity(WidgetNames.VideoSelectNearestSubtitle, sensitivity);
 354                 SetSensitivity(WidgetNames.VideoLoopSelectionPlayback, sensitivity);
 355                 SetSensitivity(WidgetNames.VideoAutoSelectSubtitles, sensitivity);
 356         }
 357
 358         private void SetCheckMenuItemActivity (string menuItemName, bool isActive) {
 359                 (Base.GetWidget(menuItemName) as CheckMenuItem).Active = isActive;
 360         }
 361
 362         private void SetCheckMenuItemActivity (string menuItemName, bool isActive, EventHandler handler) {
 363                 CheckMenuItem menuItem = Base.GetWidget(menuItemName) as CheckMenuItem;
 364                 menuItem.Toggled -= handler;
 365                 menuItem.Active = isActive;
 366                 menuItem.Toggled += handler;
 367         }
 368
 369         private void SetToggleToolButtonActivity (string toggleToolButtonName, bool isActive, EventHandler handler) {
 370                 ToggleToolButton toggleToolButton = Base.GetWidget(toggleToolButtonName) as ToggleToolButton;
 371                 toggleToolButton.Toggled -= handler;
 372                 toggleToolButton.Active = isActive;
 373                 toggleToolButton.Toggled += handler;
 374         }
 375
 376         private void SetSensitivity (string widgetName, bool isSensitive) {
 377                 Widget widget = Base.GetWidget(widgetName);
 378                 if (widget != null)
 379                         widget.Sensitive = isSensitive;
 380         }
 381
 382         private void SetMenuSensitivity (string menuName, bool sensitivity) {
 383                 Menu menu = Base.GetWidget(menuName) as Menu;
 384                 foreach (Widget widget in menu)
 385                         widget.Sensitive = sensitivity;
 386         }
 387
 388         private void GetGlobalStyles (TreePath[] paths, out bool bold, out bool italic, out bool underline) {
 389                 Ui.View.Subtitles subtitles = Base.Document.Subtitles;
 390                 bold = true;
 391                 italic = true;
 392                 underline = true;
 393                 foreach (TreePath path in paths) {
 394                         Subtitle subtitle = subtitles[path];
 395                         if ((bold == true) && !subtitle.Style.Bold) //bold hasn't been unset
 396                                 bold = false;
 397                         if ((italic == true) && !subtitle.Style.Italic)
 398                                 italic = false;
 399                         if ((underline == true) && !subtitle.Style.Underline)
 400                                 underline = false;
 401                 }
 402         }
 403
 404         private string InputFrameRateMenuItem (float frameRate) {
 405                 return FrameRateToMenuItem(frameRate, "Input");
 406         }
 407
 408         private string VideoFrameRateMenuItem (float frameRate) {
 409                 return FrameRateToMenuItem(frameRate, "Video");
 410         }
 411
 412         private string FrameRateToMenuItem (float frameRate, string type) {
 413                 int rate = 0;
 414                 if (frameRate >= 30)
 415                         rate = 30;
 416                 else if (frameRate >= 27)
 417                         rate = 29;
 418                 else if (frameRate >= 25)
 419                         rate = 25;
 420                 else if (frameRate >= 24)
 421                         rate = 24;
 422                 else
 423                         rate = 23;
 424
 425                 return "timings" + type + "FrameRate" + rate;
 426         }
 427
 428         private string GetMenuItemText (string menuItemName) {
 429                 MenuItem menuItem = Base.GetWidget(menuItemName) as MenuItem;
 430                 return GetMenuItemText(menuItem);
 431         }
 432
 433         private string GetMenuItemText (MenuItem menuItem) {
 434                 Label label = menuItem.Child as Label;
 435                 return label.Text;
 436         }
 437
 438         private void SetMenuItemText (string menuItemName, string text) {
 439                 MenuItem menuItem = Base.GetWidget(menuItemName) as MenuItem;
 440                 SetMenuItemText(menuItem, text);
 441         }
 442
 443         private void SetMenuItemText (MenuItem menuItem, string text) {
 444                 Label label = menuItem.Child as Label;
 445                 label.Text = text;
 446         }
 447
 448         private string GetVideoTagSuffix () {
 449                 return " (" + videoTagText + ")";
 450         }
 451
 452         private void SetToolbarHomogeneity () {
 453                 Toolbar toolbar = Base.GetWidget(WidgetNames.Toolbar) as Toolbar;
 454                 Widget[] toolItems = toolbar.Children;
 455                 foreach (Widget item in toolItems)
 456                         (item as ToolItem).Homogeneous = false;
 457         }
 458
 459         private void UpdateUndoRedoMessages () {
 460         CommandManager commandManager = Base.CommandManager;
 461
 462         /* Update undo messages */
 463         ToolButton undoButton = Base.GetWidget(WidgetNames.UndoButton) as ToolButton;
 464         if (commandManager.CanUndo) {
 465                 string undoDescription = commandManager.UndoDescription;
 466                         SetTooltip(undoButton, undoDescription);
 467                 MenuItem undoMenuItem = Base.GetWidget(WidgetNames.EditUndo) as MenuItem;
 468                 (undoMenuItem.Child as Label).Text = undoDescription;
 469         }
 470                 else
 471                         ClearTooltip(undoButton);
 472
 473                 /* Update redo messages */
 474                 ToolButton redoButton = Base.GetWidget(WidgetNames.RedoButton) as ToolButton;
 475         if (commandManager.CanRedo) {
 476                 string redoDescription = commandManager.RedoDescription;
 477                 SetTooltip(redoButton, redoDescription);
 478                 MenuItem redoMenuItem = Base.GetWidget(WidgetNames.EditRedo) as MenuItem;
 479                 (redoMenuItem.Child as Label).Text = redoDescription;
 480         }
 481         else
 482                 ClearTooltip(redoButton);
 483     }
 484
 485     private void SetTooltip (Widget widget, string text) {
 486         widget.TooltipText = text;
 487     }
 488
 489     private void ClearTooltip (Widget widget) {
 490         SetTooltip(widget, null);
 491     }
 492
 493         private float FrameRateFromMenuItem (string menuItem) {
 494                 string frameRateText = menuItem.Split(' ')[0];
 495                 NumberFormatInfo invariant = NumberFormatInfo.InvariantInfo;
 496                 return (float)Convert.ToDouble(frameRateText, invariant);
 497         }
 498
 499
 500         /* Event members */
 501
 502         private void OnBaseInitFinished () {
 503                 Base.DocumentLoaded += OnBaseDocumentLoaded;
 504                 Base.DocumentUnloaded += OnBaseDocumentUnloaded;
 505                 Base.VideoLoaded += OnBaseVideoLoaded;
 506                 Base.VideoUnloaded += OnBaseVideoUnloaded;
 507                 Base.TranslationLoaded += OnBaseTranslationLoaded;
 508                 Base.TranslationUnloaded += OnBaseTranslationUnloaded;
 509                 Base.Ui.View.Selection.Changed += OnSubtitleViewSelectionChanged;
 510                 Base.Ui.View.SubtitleCountChanged += OnSubtitleViewCountChanged;
 511                 Base.SpellLanguages.TextLanguageChanged += OnSpellLanguagesLanguageChanged;
 512                 Base.SpellLanguages.TranslationLanguageChanged += OnSpellLanguagesLanguageChanged;
 513                 Base.CommandManager.UndoToggled += OnCommandManagerUndoToggled;
 514                 Base.CommandManager.RedoToggled += OnCommandManagerRedoToggled;
 515                 Base.CommandManager.CommandActivated += OnCommandManagerCommandActivated;
 516
 517                 (Base.GetWidget(WidgetNames.ViewLineLengths) as CheckMenuItem).Toggled += OnViewLineLengthsToggled;
 518         }
 519
 520         private void OnBaseDocumentLoaded (Document document) {
 521                 SetDocumentSensitivity(true);
 522                 SetFrameRateMenus(true);
 523                 SetActiveTimingMode(Base.TimingMode);
 524                 SetCheckMenuItemActivity(WidgetNames.ToolsAutocheckSpelling, Base.SpellLanguages.Enabled);
 525         }
 526
 527         private void OnBaseDocumentUnloaded (Document document) {
 528                 SetDocumentSensitivity(false);
 529                 SetFrameRateMenus(false);
 530         }
 531
 532         private void OnBaseVideoLoaded (Uri videoUri) {
 533                 SetVideoSensitivity(true);
 534         SetViewVideoSubtitlesSensitivity();
 535         SetViewVideoActivity(true);
 536
 537                 if (Base.Ui.Video.HasVideo) {
 538                         AddFrameRateVideoTag(Base.Ui.Video.FrameRate);
 539                 }
 540         }
 541
 542         private void OnBaseVideoUnloaded () {
 543                 SetVideoSensitivity(false);
 544         SetViewVideoSubtitlesSensitivity(false, false);
 545         }
 546
 547         private void OnSubtitleViewCountChanged (int count) {
 548                 SetSubtitleCountDependentSensitivity(count);
 549         }
 550
 551         private void OnBaseTranslationLoaded () {
 552                 SetTranslationSensitivity(true);
 553                 UpdateUndoRedoMessages();
 554         }
 555
 556         private void OnBaseTranslationUnloaded () {
 557                 SetTranslationSensitivity(false);
 558         SetViewVideoSubtitlesActivity(true);
 559         UpdateUndoRedoMessages();
 560         }
 561
 562         private void OnSubtitleViewSelectionChanged (TreePath[] paths, Subtitle subtitle) {
 563                 if (subtitle != null) {
 564                         /* One subtitle selected */
 565                         SetStylesActivity(subtitle.Style.Bold, subtitle.Style.Italic, subtitle.Style.Underline);
 566                         SetNonZeroSelectionDependentSensitivity(true);
 567                         SetOneSelectionDependentSensitivity(true);
 568                 }
 569                 else {
 570                         SetOneSelectionDependentSensitivity(false);
 571
 572                         if (paths.Length == 0) {
 573                                 /* No selection */
 574                                 SetNonZeroSelectionDependentSensitivity(false);
 575                                 SetStylesActivity(false, false, false);
 576                         }
 577                         else {
 578                                 /* Multiple paths selected */
 579                                 SetNonZeroSelectionDependentSensitivity(true);
 580                                 bool bold, italic, underline;
 581                                 GetGlobalStyles(paths, out bold, out italic, out underline);
 582                                 SetStylesActivity(bold, italic, underline);
 583                         }
 584                 }
 585         }
 586
 587         private void OnSpellLanguagesLanguageChanged () {
 588                 SetToolsAutocheckSpellingSensitivity(true);
 589         }
 590
 591         private void OnCommandManagerUndoToggled (object o, EventArgs args)  {
 592                 Widget button = Base.GetWidget(WidgetNames.UndoButton);
 593                 button.Sensitive = !button.Sensitive;
 594
 595                 MenuItem menuItem = Base.GetWidget(WidgetNames.EditUndo) as MenuItem;
 596                 menuItem.Sensitive = !menuItem.Sensitive;
 597                 if (!menuItem.Sensitive)
 598                         (menuItem.Child as Label).Text = Catalog.GetString("Undo");
 599         }
 600
 601         private void OnCommandManagerRedoToggled (object o, EventArgs args) {
 602         Widget button = Base.GetWidget(WidgetNames.RedoButton);
 603         button.Sensitive = !button.Sensitive;
 604
 605                 MenuItem menuItem = Base.GetWidget(WidgetNames.EditRedo) as MenuItem;
 606         menuItem.Sensitive = !menuItem.Sensitive;
 607         if (!menuItem.Sensitive)
 608                         (menuItem.Child as Label).Text = Catalog.GetString("Redo");
 609     }
 610
 611     private void OnCommandManagerCommandActivated (object o, CommandActivatedArgs args) {
 612         UpdateUndoRedoMessages();
 613     }
 614
 615
 616         private void OnTimingsInputFrameRateToggled (object o, EventArgs args) {
 617                 RadioMenuItem menuItem = o as RadioMenuItem;
 618                 if (menuItem.Active) {
 619                         float frameRate = FrameRateFromMenuItem((menuItem.Child as Label).Text);
 620                         Base.CommandManager.Execute(new ChangeInputFrameRateCommand(frameRate));
 621                 }
 622         }
 623
 624         private void OnTimingsVideoFrameRateToggled (object o, EventArgs args) {
 625                 RadioMenuItem menuItem = o as RadioMenuItem;
 626                 if (menuItem.Active) {
 627                         float frameRate = FrameRateFromMenuItem((menuItem.Child as Label).Text);
 628                         Base.CommandManager.Execute(new ChangeVideoFrameRateCommand(frameRate));
 629                 }
 630         }
 631
 632         private void SetFrameRateMenuHandlers (Menu menu, bool enable, EventHandler handler) {
 633                 foreach (RadioMenuItem menuItem in menu.Children) {
 634                         if (enable)
 635                                 menuItem.Toggled += handler;
 636                         else
 637                                 menuItem.Toggled -= handler;
 638                 }
 639         }
 640
 641         private void OnViewLineLengthsToggled (object o, EventArgs args) {
 642                 bool newValue = ((o as CheckMenuItem).Active);
 643                 if (newValue != viewLineLengthsEnabled) {
 644                         viewLineLengthsEnabled = newValue;
 645                         Base.Config.PrefsViewLineLengths = newValue;
 646                         Base.Ui.View.Refresh();
 647                 }
 648         }
 649
 650 }
 651
 652 }