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                 SetViewVideoSubtitlesSensitivity();
 238         }
 239
 240         private void SetToolsAutocheckSpellingSensitivity (bool sensitivity) {
 241                 SetSensitivity(WidgetNames.ToolsAutocheckSpelling, sensitivity);
 242         }
 243
 244         private void SetFrameRateMenus (bool documentLoaded) {
 245                 if (documentLoaded) {
 246                         if (Base.TimingMode == TimingMode.Frames) {
 247                                 UpdateActiveInputFrameRateMenuItem(false);
 248                                 SetMenuSensitivity(WidgetNames.TimingsInputFrameRateMenu, true);
 249                                 SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsInputFrameRateMenu) as Menu, true, OnTimingsInputFrameRateToggled);
 250
 251                                 SetMenuSensitivity(WidgetNames.TimingsVideoFrameRateMenu, true);
 252                                 SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu, true, OnTimingsVideoFrameRateToggled);
 253                                 UpdateActiveVideoFrameRateMenuItem();
 254                         }
 255                         else {
 256                                 UpdateActiveInputFrameRateMenuItem(false);
 257                                 SetMenuSensitivity(WidgetNames.TimingsInputFrameRateMenu, false);
 258
 259                                 SetMenuSensitivity(WidgetNames.TimingsVideoFrameRateMenu, true);
 260                                 SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu, true, OnTimingsVideoFrameRateToggled);
 261                                 UpdateActiveVideoFrameRateMenuItem();
 262                         }
 263                 }
 264                 else {
 265                         SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsInputFrameRateMenu) as Menu, false, OnTimingsInputFrameRateToggled);
 266                         SetMenuSensitivity(WidgetNames.TimingsInputFrameRateMenu, true);
 267                         SetFrameRateMenuHandlers(Base.GetWidget(WidgetNames.TimingsVideoFrameRateMenu) as Menu, false, OnTimingsVideoFrameRateToggled);
 268                         SetMenuSensitivity(WidgetNames.TimingsVideoFrameRateMenu, false);
 269                 }
 270         }
 271
 272         private void SetStylesActivity (bool bold, bool italic, bool underline) {
 273                 SetCheckMenuItemActivity(WidgetNames.EditFormatBold, bold, Base.Handlers.OnEditFormatBold);
 274                 SetCheckMenuItemActivity(WidgetNames.EditFormatItalic, italic, Base.Handlers.OnEditFormatItalic);
 275                 SetCheckMenuItemActivity(WidgetNames.EditFormatUnderline, underline, Base.Handlers.OnEditFormatUnderline);
 276                 SetToggleToolButtonActivity(WidgetNames.BoldButton, bold, Base.Handlers.OnEditFormatBold);
 277                 SetToggleToolButtonActivity(WidgetNames.ItalicButton, italic, Base.Handlers.OnEditFormatItalic);
 278                 SetToggleToolButtonActivity(WidgetNames.UnderlineButton, underline, Base.Handlers.OnEditFormatUnderline);
 279         }
 280
 281         private void SetActiveTimingMode (TimingMode mode) {
 282                 if (mode == TimingMode.Times)
 283                         SetCheckMenuItemActivity(WidgetNames.ViewTimes, true);
 284                 else
 285                         SetCheckMenuItemActivity(WidgetNames.ViewFrames, true);
 286         }
 287
 288         private void SetViewVideoSubtitlesActivity (bool isTextActive) {
 289                 if (isTextActive)
 290                         SetCheckMenuItemActivity(WidgetNames.ViewVideoSubtitlesText, true);
 291                 else
 292                         SetCheckMenuItemActivity(WidgetNames.ViewVideoSubtitlesTranslation, true);
 293         }
 294
 295         private void SetVideoSensitivity (bool sensitivity) {
 296                 SetSensitivity(WidgetNames.VideoClose, sensitivity);
 297                 SetSensitivity(WidgetNames.VideoPlayPause, sensitivity);
 298                 SetSensitivity(WidgetNames.VideoRewind, sensitivity);
 299                 SetSensitivity(WidgetNames.VideoForward, sensitivity);
 300                 SetSensitivity(WidgetNames.VideoSeekTo, sensitivity);
 301                 SetVideoDocumentLoadedSensitivity(Base.IsDocumentLoaded);
 302
 303                 /* Set video menu dependent sensitivity if there is 1 selected subtitle. */
 304                 if ((Core.Base.Ui.View.Selection.Count == 1) && sensitivity)
 305                         SetVideoSelectionDependentSensitivity(true);
 306                 else
 307                         SetVideoSelectionDependentSensitivity(false);
 308         }
 309
 310         private void SetStylesSensitivity (bool sensitivity) {
 311                 if (Base.GetWidget(WidgetNames.EditFormatBold).Sensitive != sensitivity) {
 312                         SetSensitivity(WidgetNames.EditFormatBold, sensitivity);
 313                         SetSensitivity(WidgetNames.EditFormatItalic, sensitivity);
 314                         SetSensitivity(WidgetNames.EditFormatUnderline, sensitivity);
 315                         SetSensitivity(WidgetNames.BoldButton, sensitivity);
 316                         SetSensitivity(WidgetNames.ItalicButton, sensitivity);
 317                         SetSensitivity(WidgetNames.UnderlineButton, sensitivity);
 318                 }
 319         }
 320
 321         /// <summary>Set the video selection dependent menu items.</summary>
 322         /// <param name="sensitivity">Whether to set the menu items sensitive.</param>
 323         /// <remarks>The menu items are only set sensitive if the video is loaded.</remarks>
 324         private void SetVideoSelectionDependentSensitivity (bool sensitivity) {
 325                 if (Core.Base.Ui.Video.IsLoaded && sensitivity) {//TODO improve this
 326                         SetSensitivity(WidgetNames.VideoSeekToSelection, true);
 327                         SetSensitivity(WidgetNames.VideoSetSubtitleStart, true);
 328                         SetSensitivity(WidgetNames.VideoSetSubtitleEnd, true);
 329                 }
 330                 else {
 331                         SetSensitivity(WidgetNames.VideoSeekToSelection, false);
 332                         SetSensitivity(WidgetNames.VideoSetSubtitleStart, false);
 333                         SetSensitivity(WidgetNames.VideoSetSubtitleEnd, false);
 334                 }
 335         }
 336
 337         private void SetViewVideoSubtitlesSensitivity () {
 338                 bool isVideoLoaded = (Base.Ui != null) && Base.Ui.Video.IsLoaded;
 339                 bool textSensitivity = isVideoLoaded && Base.IsDocumentLoaded;
 340                 bool translationSensitivity = isVideoLoaded && textSensitivity && Base.Document.IsTranslationLoaded;
 341                 SetViewVideoSubtitlesSensitivity(textSensitivity, translationSensitivity);
 342         }
 343
 344         private void SetViewVideoSubtitlesSensitivity (bool textSensitivity, bool translationSensitivity) {
 345                 SetSensitivity(WidgetNames.ViewVideoSubtitlesText, textSensitivity);
 346                 SetSensitivity(WidgetNames.ViewVideoSubtitlesTranslation, translationSensitivity);
 347         }
 348
 349         private void SetVideoDocumentLoadedSensitivity (bool isDocumentLoaded) {
 350                 bool sensitivity = isDocumentLoaded && (Base.Ui != null) && Base.Ui.Video.IsLoaded;
 351                 SetSensitivity(WidgetNames.VideoSelectNearestSubtitle, sensitivity);
 352                 SetSensitivity(WidgetNames.VideoLoopSelectionPlayback, sensitivity);
 353                 SetSensitivity(WidgetNames.VideoAutoSelectSubtitles, sensitivity);
 354         }
 355
 356         private void SetCheckMenuItemActivity (string menuItemName, bool isActive) {
 357                 (Base.GetWidget(menuItemName) as CheckMenuItem).Active = isActive;
 358         }
 359
 360         private void SetCheckMenuItemActivity (string menuItemName, bool isActive, EventHandler handler) {
 361                 CheckMenuItem menuItem = Base.GetWidget(menuItemName) as CheckMenuItem;
 362                 menuItem.Toggled -= handler;
 363                 menuItem.Active = isActive;
 364                 menuItem.Toggled += handler;
 365         }
 366
 367         private void SetToggleToolButtonActivity (string toggleToolButtonName, bool isActive, EventHandler handler) {
 368                 ToggleToolButton toggleToolButton = Base.GetWidget(toggleToolButtonName) as ToggleToolButton;
 369                 toggleToolButton.Toggled -= handler;
 370                 toggleToolButton.Active = isActive;
 371                 toggleToolButton.Toggled += handler;
 372         }
 373
 374         private void SetSensitivity (string widgetName, bool isSensitive) {
 375                 Widget widget = Base.GetWidget(widgetName);
 376                 if (widget != null)
 377                         widget.Sensitive = isSensitive;
 378         }
 379
 380         private void SetMenuSensitivity (string menuName, bool sensitivity) {
 381                 Menu menu = Base.GetWidget(menuName) as Menu;
 382                 foreach (Widget widget in menu)
 383                         widget.Sensitive = sensitivity;
 384         }
 385
 386         private void GetGlobalStyles (TreePath[] paths, out bool bold, out bool italic, out bool underline) {
 387                 Ui.View.Subtitles subtitles = Base.Document.Subtitles;
 388                 bold = true;
 389                 italic = true;
 390                 underline = true;
 391                 foreach (TreePath path in paths) {
 392                         Subtitle subtitle = subtitles[path];
 393                         if ((bold == true) && !subtitle.Style.Bold) //bold hasn't been unset
 394                                 bold = false;
 395                         if ((italic == true) && !subtitle.Style.Italic)
 396                                 italic = false;
 397                         if ((underline == true) && !subtitle.Style.Underline)
 398                                 underline = false;
 399                 }
 400         }
 401
 402         private string InputFrameRateMenuItem (float frameRate) {
 403                 return FrameRateToMenuItem(frameRate, "Input");
 404         }
 405
 406         private string VideoFrameRateMenuItem (float frameRate) {
 407                 return FrameRateToMenuItem(frameRate, "Video");
 408         }
 409
 410         private string FrameRateToMenuItem (float frameRate, string type) {
 411                 int rate = 0;
 412                 if (frameRate >= 30)
 413                         rate = 30;
 414                 else if (frameRate >= 27)
 415                         rate = 29;
 416                 else if (frameRate >= 25)
 417                         rate = 25;
 418                 else if (frameRate >= 24)
 419                         rate = 24;
 420                 else
 421                         rate = 23;
 422
 423                 return "timings" + type + "FrameRate" + rate;
 424         }
 425
 426         private string GetMenuItemText (string menuItemName) {
 427                 MenuItem menuItem = Base.GetWidget(menuItemName) as MenuItem;
 428                 return GetMenuItemText(menuItem);
 429         }
 430
 431         private string GetMenuItemText (MenuItem menuItem) {
 432                 Label label = menuItem.Child as Label;
 433                 return label.Text;
 434         }
 435
 436         private void SetMenuItemText (string menuItemName, string text) {
 437                 MenuItem menuItem = Base.GetWidget(menuItemName) as MenuItem;
 438                 SetMenuItemText(menuItem, text);
 439         }
 440
 441         private void SetMenuItemText (MenuItem menuItem, string text) {
 442                 Label label = menuItem.Child as Label;
 443                 label.Text = text;
 444         }
 445
 446         private string GetVideoTagSuffix () {
 447                 return " (" + videoTagText + ")";
 448         }
 449
 450         private void SetToolbarHomogeneity () {
 451                 Toolbar toolbar = Base.GetWidget(WidgetNames.Toolbar) as Toolbar;
 452                 Widget[] toolItems = toolbar.Children;
 453                 foreach (Widget item in toolItems)
 454                         (item as ToolItem).Homogeneous = false;
 455         }
 456
 457         private void UpdateUndoRedoMessages () {
 458         CommandManager commandManager = Base.CommandManager;
 459
 460         /* Update undo messages */
 461         ToolButton undoButton = Base.GetWidget(WidgetNames.UndoButton) as ToolButton;
 462         if (commandManager.CanUndo) {
 463                 string undoDescription = commandManager.UndoDescription;
 464                         SetTooltip(undoButton, undoDescription);
 465                 MenuItem undoMenuItem = Base.GetWidget(WidgetNames.EditUndo) as MenuItem;
 466                 (undoMenuItem.Child as Label).Text = undoDescription;
 467         }
 468                 else
 469                         ClearTooltip(undoButton);
 470
 471                 /* Update redo messages */
 472                 ToolButton redoButton = Base.GetWidget(WidgetNames.RedoButton) as ToolButton;
 473         if (commandManager.CanRedo) {
 474                 string redoDescription = commandManager.RedoDescription;
 475                 SetTooltip(redoButton, redoDescription);
 476                 MenuItem redoMenuItem = Base.GetWidget(WidgetNames.EditRedo) as MenuItem;
 477                 (redoMenuItem.Child as Label).Text = redoDescription;
 478         }
 479         else
 480                 ClearTooltip(redoButton);
 481     }
 482
 483     private void SetTooltip (Widget widget, string text) {
 484         widget.TooltipText = text;
 485     }
 486
 487     private void ClearTooltip (Widget widget) {
 488         SetTooltip(widget, null);
 489     }
 490
 491         private float FrameRateFromMenuItem (string menuItem) {
 492                 string frameRateText = menuItem.Split(' ')[0];
 493                 NumberFormatInfo invariant = NumberFormatInfo.InvariantInfo;
 494                 return (float)Convert.ToDouble(frameRateText, invariant);
 495         }
 496
 497
 498         /* Event members */
 499
 500         private void OnBaseInitFinished () {
 501                 Base.DocumentLoaded += OnBaseDocumentLoaded;
 502                 Base.DocumentUnloaded += OnBaseDocumentUnloaded;
 503                 Base.VideoLoaded += OnBaseVideoLoaded;
 504                 Base.VideoUnloaded += OnBaseVideoUnloaded;
 505                 Base.TranslationLoaded += OnBaseTranslationLoaded;
 506                 Base.TranslationUnloaded += OnBaseTranslationUnloaded;
 507                 Base.Ui.View.Selection.Changed += OnSubtitleViewSelectionChanged;
 508                 Base.Ui.View.SubtitleCountChanged += OnSubtitleViewCountChanged;
 509                 Base.SpellLanguages.TextLanguageChanged += OnSpellLanguagesLanguageChanged;
 510                 Base.SpellLanguages.TranslationLanguageChanged += OnSpellLanguagesLanguageChanged;
 511                 Base.CommandManager.UndoToggled += OnCommandManagerUndoToggled;
 512                 Base.CommandManager.RedoToggled += OnCommandManagerRedoToggled;
 513                 Base.CommandManager.CommandActivated += OnCommandManagerCommandActivated;
 514
 515                 (Base.GetWidget(WidgetNames.ViewLineLengths) as CheckMenuItem).Toggled += OnViewLineLengthsToggled;
 516         }
 517
 518         private void OnBaseDocumentLoaded (Document document) {
 519                 SetDocumentSensitivity(true);
 520                 SetFrameRateMenus(true);
 521                 SetActiveTimingMode(Base.TimingMode);
 522                 SetCheckMenuItemActivity(WidgetNames.ToolsAutocheckSpelling, Base.SpellLanguages.Enabled);
 523         }
 524
 525         private void OnBaseDocumentUnloaded (Document document) {
 526                 SetDocumentSensitivity(false);
 527                 SetFrameRateMenus(false);
 528         }
 529
 530         private void OnBaseVideoLoaded (Uri videoUri) {
 531                 SetVideoSensitivity(true);
 532         SetViewVideoSubtitlesSensitivity();
 533         SetViewVideoActivity(true);
 534
 535                 if (Base.Ui.Video.HasVideo) {
 536                         AddFrameRateVideoTag(Base.Ui.Video.FrameRate);
 537                 }
 538         }
 539
 540         private void OnBaseVideoUnloaded () {
 541                 SetVideoSensitivity(false);
 542         SetViewVideoSubtitlesSensitivity(false, false);
 543         }
 544
 545         private void OnSubtitleViewCountChanged (int count) {
 546                 SetSubtitleCountDependentSensitivity(count);
 547         }
 548
 549         private void OnBaseTranslationLoaded () {
 550                 SetTranslationSensitivity(true);
 551                 UpdateUndoRedoMessages();
 552         }
 553
 554         private void OnBaseTranslationUnloaded () {
 555                 SetTranslationSensitivity(false);
 556         SetViewVideoSubtitlesActivity(true);
 557         UpdateUndoRedoMessages();
 558         }
 559
 560         private void OnSubtitleViewSelectionChanged (TreePath[] paths, Subtitle subtitle) {
 561                 if (subtitle != null) {
 562                         /* One subtitle selected */
 563                         SetStylesActivity(subtitle.Style.Bold, subtitle.Style.Italic, subtitle.Style.Underline);
 564                         SetNonZeroSelectionDependentSensitivity(true);
 565                         SetOneSelectionDependentSensitivity(true);
 566                 }
 567                 else {
 568                         SetOneSelectionDependentSensitivity(false);
 569
 570                         if (paths.Length == 0) {
 571                                 /* No selection */
 572                                 SetNonZeroSelectionDependentSensitivity(false);
 573                                 SetStylesActivity(false, false, false);
 574                         }
 575                         else {
 576                                 /* Multiple paths selected */
 577                                 SetNonZeroSelectionDependentSensitivity(true);
 578                                 bool bold, italic, underline;
 579                                 GetGlobalStyles(paths, out bold, out italic, out underline);
 580                                 SetStylesActivity(bold, italic, underline);
 581                         }
 582                 }
 583         }
 584
 585         private void OnSpellLanguagesLanguageChanged () {
 586                 SetToolsAutocheckSpellingSensitivity(true);
 587         }
 588
 589         private void OnCommandManagerUndoToggled (object o, EventArgs args)  {
 590                 Widget button = Base.GetWidget(WidgetNames.UndoButton);
 591                 button.Sensitive = !button.Sensitive;
 592
 593                 MenuItem menuItem = Base.GetWidget(WidgetNames.EditUndo) as MenuItem;
 594                 menuItem.Sensitive = !menuItem.Sensitive;
 595                 if (!menuItem.Sensitive)
 596                         (menuItem.Child as Label).Text = Catalog.GetString("Undo");
 597         }
 598
 599         private void OnCommandManagerRedoToggled (object o, EventArgs args) {
 600         Widget button = Base.GetWidget(WidgetNames.RedoButton);
 601         button.Sensitive = !button.Sensitive;
 602
 603                 MenuItem menuItem = Base.GetWidget(WidgetNames.EditRedo) as MenuItem;
 604         menuItem.Sensitive = !menuItem.Sensitive;
 605         if (!menuItem.Sensitive)
 606                         (menuItem.Child as Label).Text = Catalog.GetString("Redo");
 607     }
 608
 609     private void OnCommandManagerCommandActivated (object o, CommandActivatedArgs args) {
 610         UpdateUndoRedoMessages();
 611     }
 612
 613
 614         private void OnTimingsInputFrameRateToggled (object o, EventArgs args) {
 615                 RadioMenuItem menuItem = o as RadioMenuItem;
 616                 if (menuItem.Active) {
 617                         float frameRate = FrameRateFromMenuItem((menuItem.Child as Label).Text);
 618                         Base.CommandManager.Execute(new ChangeInputFrameRateCommand(frameRate));
 619                 }
 620         }
 621
 622         private void OnTimingsVideoFrameRateToggled (object o, EventArgs args) {
 623                 RadioMenuItem menuItem = o as RadioMenuItem;
 624                 if (menuItem.Active) {
 625                         float frameRate = FrameRateFromMenuItem((menuItem.Child as Label).Text);
 626                         Base.CommandManager.Execute(new ChangeVideoFrameRateCommand(frameRate));
 627                 }
 628         }
 629
 630         private void SetFrameRateMenuHandlers (Menu menu, bool enable, EventHandler handler) {
 631                 foreach (RadioMenuItem menuItem in menu.Children) {
 632                         if (enable)
 633                                 menuItem.Toggled += handler;
 634                         else
 635                                 menuItem.Toggled -= handler;
 636                 }
 637         }
 638
 639         private void OnViewLineLengthsToggled (object o, EventArgs args) {
 640                 bool newValue = ((o as CheckMenuItem).Active);
 641                 if (newValue != viewLineLengthsEnabled) {
 642                         viewLineLengthsEnabled = newValue;
 643                         Base.Config.PrefsViewLineLengths = newValue;
 644                         Base.Ui.View.Refresh();
 645                 }
 646         }
 647
 648 }
 649
 650 }