src/TortoiseMerge/NativeRibbonApp.cpp

   1 // TortoiseGitMerge - a Diff/Patch program
   2
   3 // Copyright (C) 2017, 2019, 2023 - TortoiseGit
   4 // Copyright (C) 2017 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20
  21 #include "stdafx.h"
  22 #include "NativeRibbonApp.h"
  23
  24 CNativeRibbonApp::CNativeRibbonApp(CFrameWnd* pFrame, IUIFramework* pFramework)
  25         : m_pFrame(pFrame)
  26         , m_pFramework(pFramework)
  27 {
  28 }
  29
  30 CNativeRibbonApp::~CNativeRibbonApp()
  31 {
  32         ASSERT(m_cRefCount == 0);
  33 }
  34
  35 STDMETHODIMP CNativeRibbonApp::QueryInterface(REFIID riid, void **ppvObject)
  36 {
  37         if (riid == IID_IUnknown)
  38         {
  39                 AddRef();
  40                 *ppvObject = static_cast<IUICommandHandler*>(this);
  41                 return S_OK;
  42         }
  43         else if (riid == __uuidof(IUIApplication))
  44         {
  45                 AddRef();
  46                 *ppvObject = static_cast<IUIApplication*>(this);
  47                 return S_OK;
  48         }
  49         else if (riid == __uuidof(IUICommandHandler))
  50         {
  51                 AddRef();
  52                 *ppvObject = static_cast<IUICommandHandler*>(this);
  53                 return S_OK;
  54         }
  55         else
  56         {
  57                 return E_NOINTERFACE;
  58         }
  59 }
  60
  61 STDMETHODIMP_(ULONG) CNativeRibbonApp::AddRef(void)
  62 {
  63         return InterlockedIncrement(&m_cRefCount);
  64 }
  65
  66 STDMETHODIMP_(ULONG) CNativeRibbonApp::Release(void)
  67 {
  68         return InterlockedDecrement(&m_cRefCount);
  69 }
  70
  71 STDMETHODIMP CNativeRibbonApp::OnViewChanged(UINT32 /*viewId*/, UI_VIEWTYPE typeID, IUnknown* view, UI_VIEWVERB verb, INT32 /*uReasonCode*/)
  72 {
  73         if (typeID == UI_VIEWTYPE_RIBBON)
  74         {
  75                 if (verb == UI_VIEWVERB_CREATE)
  76                 {
  77                         if (!m_SettingsFileName.IsEmpty())
  78                         {
  79                                 CComQIPtr<IUIRibbon> ribbonView(view);
  80                                 if (ribbonView)
  81                                         LoadRibbonViewSettings(ribbonView, m_SettingsFileName);
  82                         }
  83
  84                         m_pFrame->RecalcLayout();
  85                 }
  86                 else if (verb == UI_VIEWVERB_DESTROY)
  87                 {
  88                         CComQIPtr<IUIRibbon> ribbonView(view);
  89                         if (ribbonView)
  90                                 SaveRibbonViewSettings(ribbonView, m_SettingsFileName);
  91                 }
  92                 else if (verb == UI_VIEWVERB_SIZE)
  93                         m_pFrame->RecalcLayout();
  94         }
  95
  96         return S_OK;
  97 }
  98
  99 STDMETHODIMP CNativeRibbonApp::OnCreateUICommand(UINT32 commandId, UI_COMMANDTYPE typeID, IUICommandHandler** commandHandler)
 100 {
 101         m_commandIds.push_back(commandId);
 102         if (typeID == UI_COMMANDTYPE_COLLECTION)
 103                 m_collectionCommandIds.push_back(commandId);
 104
 105         return QueryInterface(IID_PPV_ARGS(commandHandler));
 106 }
 107
 108 STDMETHODIMP CNativeRibbonApp::OnDestroyUICommand(UINT32 commandId, UI_COMMANDTYPE /*typeID*/, IUICommandHandler* /*commandHandler*/)
 109 {
 110         m_commandIds.remove(commandId);
 111
 112         return S_OK;
 113 }
 114
 115 STDMETHODIMP CNativeRibbonApp::Execute(UINT32 commandId, UI_EXECUTIONVERB verb, const PROPERTYKEY* key, const PROPVARIANT* currentValue, IUISimplePropertySet* /*commandExecutionProperties*/)
 116 {
 117         if (verb == UI_EXECUTIONVERB_EXECUTE)
 118         {
 119                 if (key && IsEqualPropertyKey(*key, UI_PKEY_SelectedItem))
 120                 {
 121                         CComPtr<IUICollection> items = GetUICommandItemsSource(commandId);
 122                         UINT32 selectedItemIdx = 0;
 123                         UIPropertyToUInt32(UI_PKEY_SelectedItem, *currentValue, &selectedItemIdx);
 124                         UINT32 count = 0;
 125                         items->GetCount(&count);
 126
 127                         if (selectedItemIdx < count)
 128                         {
 129                                 CComPtr<IUnknown> selectedItemUnk;
 130                                 items->GetItem(selectedItemIdx, &selectedItemUnk);
 131                                 CComQIPtr<IUISimplePropertySet> selectedItemPropSet(selectedItemUnk);
 132                                 if (selectedItemPropSet)
 133                                         m_pFrame->PostMessage(WM_COMMAND, GetCommandIdProperty(selectedItemPropSet));
 134                         }
 135                 }
 136                 else
 137                         m_pFrame->PostMessage(WM_COMMAND, commandId);
 138
 139                 return S_OK;
 140         }
 141
 142         return S_FALSE;
 143 }
 144
 145 class CRibbonCmdUI : public CCmdUI
 146 {
 147 public:
 148         CString m_Text;
 149         BOOL m_bOn;
 150         int m_nCheck;
 151         int m_bCheckChanged;
 152
 153         CRibbonCmdUI(int commandId)
 154                 : m_bOn(FALSE)
 155                 , m_nCheck(0)
 156                 , m_bCheckChanged(FALSE)
 157         {
 158                 m_nID = commandId;
 159         }
 160
 161         virtual void Enable(BOOL bOn)
 162         {
 163                 m_bOn = bOn;
 164                 m_bEnableChanged = TRUE;
 165         }
 166
 167         virtual void SetCheck(int nCheck)
 168         {
 169                 m_nCheck = nCheck;
 170                 m_bCheckChanged = TRUE;
 171         }
 172
 173         virtual void SetText(LPCWSTR lpszText)
 174         {
 175                 m_Text = lpszText;
 176         }
 177 };
 178
 179 STDMETHODIMP CNativeRibbonApp::UpdateProperty(UINT32 commandId, REFPROPERTYKEY key, const PROPVARIANT* /*currentValue*/, PROPVARIANT* newValue)
 180 {
 181         if (key == UI_PKEY_TooltipTitle)
 182         {
 183                 CString str;
 184                 if (!str.LoadString(commandId))
 185                         return S_FALSE;
 186
 187                 int nIndex = str.Find(L'\n');
 188                 if (nIndex <= 0)
 189                         return S_FALSE;
 190
 191                 str = str.Mid(nIndex + 1);
 192
 193                 CString strLabel;
 194
 195                 if (m_pFrame != NULL && (CKeyboardManager::FindDefaultAccelerator(commandId, strLabel, m_pFrame, TRUE) ||
 196                         CKeyboardManager::FindDefaultAccelerator(commandId, strLabel, m_pFrame->GetActiveFrame(), FALSE)))
 197                 {
 198                         str += _T(" (");
 199                         str += strLabel;
 200                         str += _T(')');
 201                 }
 202
 203                 return UIInitPropertyFromString(UI_PKEY_TooltipTitle, str, newValue);
 204         }
 205         else if (key == UI_PKEY_TooltipDescription)
 206         {
 207                 CString str;
 208                 if (!str.LoadString(commandId))
 209                         return S_FALSE;
 210
 211                 int nIndex = str.Find(L'\n');
 212                 if (nIndex <= 0)
 213                         return S_FALSE;
 214
 215                 str = str.Left(nIndex);
 216
 217                 return UIInitPropertyFromString(UI_PKEY_TooltipDescription, str, newValue);
 218         }
 219         else if (key == UI_PKEY_Enabled)
 220         {
 221                 CRibbonCmdUI ui(commandId);
 222                 ui.DoUpdate(m_pFrame, TRUE);
 223
 224                 return UIInitPropertyFromBoolean(UI_PKEY_Enabled, ui.m_bOn, newValue);
 225         }
 226         else if (key == UI_PKEY_BooleanValue)
 227         {
 228                 CRibbonCmdUI ui(commandId);
 229                 ui.DoUpdate(m_pFrame, TRUE);
 230
 231                 return UIInitPropertyFromBoolean(UI_PKEY_BooleanValue, ui.m_nCheck, newValue);
 232         }
 233         else if (key == UI_PKEY_SelectedItem)
 234         {
 235                 CComPtr<IUICollection> items = GetUICommandItemsSource(commandId);
 236                 if (!items)
 237                         return E_FAIL;
 238
 239                 UINT32 count;
 240                 items->GetCount(&count);
 241                 for (UINT32 idx = 0; idx < count; idx++)
 242                 {
 243                         CComPtr<IUnknown> item;
 244                         items->GetItem(idx, &item);
 245
 246                         CComQIPtr<IUISimplePropertySet> simplePropertySet(item);
 247                         if (simplePropertySet)
 248                         {
 249                                 PROPVARIANT var = { 0 };
 250                                 UINT32 uiVal;
 251                                 simplePropertySet->GetValue(UI_PKEY_CommandId, &var);
 252                                 UIPropertyToUInt32(UI_PKEY_CommandId, var, &uiVal);
 253
 254                                 CRibbonCmdUI ui(uiVal);
 255                                 ui.DoUpdate(m_pFrame, TRUE);
 256
 257                                 if (ui.m_nCheck)
 258                                 {
 259                                         UIInitPropertyFromUInt32(UI_PKEY_SelectedItem, idx, newValue);
 260                                         return S_OK;
 261                                 }
 262                         }
 263                 }
 264
 265                 // No selected item.
 266                 UIInitPropertyFromUInt32(UI_PKEY_SelectedItem, static_cast<UINT>(-1), newValue);
 267
 268                 return S_OK;
 269         }
 270
 271         return E_NOTIMPL;
 272 }
 273
 274 HRESULT CNativeRibbonApp::SaveRibbonViewSettings(IUIRibbon* pRibbonView, const CString& fileName)
 275 {
 276         CComPtr<IStream> stream;
 277         HRESULT hr = SHCreateStreamOnFileEx(fileName, STGM_WRITE | STGM_CREATE, FILE_ATTRIBUTE_NORMAL, TRUE, nullptr, &stream);
 278         if (FAILED(hr))
 279                 return hr;
 280
 281         hr = pRibbonView->SaveSettingsToStream(stream);
 282         if (FAILED(hr))
 283         {
 284                 stream->Revert();
 285                 return hr;
 286         }
 287
 288         hr = stream->Commit(STGC_DEFAULT);
 289
 290         return hr;
 291 }
 292
 293 HRESULT CNativeRibbonApp::LoadRibbonViewSettings(IUIRibbon* pRibbonView, const CString& fileName)
 294 {
 295         CComPtr<IStream> stream;
 296         HRESULT hr = SHCreateStreamOnFileEx(fileName, STGM_READ, FILE_ATTRIBUTE_NORMAL, FALSE, nullptr, &stream);
 297         if (FAILED(hr))
 298                 return hr;
 299
 300         hr = pRibbonView->LoadSettingsFromStream(stream);
 301
 302         return hr;
 303 }
 304
 305 CComPtr<IUICollection> CNativeRibbonApp::GetUICommandItemsSource(UINT commandId)
 306 {
 307         PROPVARIANT prop = { 0 };
 308
 309         m_pFramework->GetUICommandProperty(commandId, UI_PKEY_ItemsSource, &prop);
 310
 311         CComPtr<IUICollection> uiCollection;
 312         UIPropertyToInterface(UI_PKEY_ItemsSource, prop, &uiCollection);
 313         PropVariantClear(&prop);
 314
 315         return uiCollection;
 316 }
 317
 318 void CNativeRibbonApp::SetUICommandItemsSource(UINT commandId, IUICollection* pItems)
 319 {
 320         PROPVARIANT prop = { 0 };
 321
 322         UIInitPropertyFromInterface(UI_PKEY_ItemsSource, pItems, &prop);
 323
 324         m_pFramework->SetUICommandProperty(commandId, UI_PKEY_ItemsSource, prop);
 325
 326         PropVariantClear(&prop);
 327 }
 328
 329 UINT CNativeRibbonApp::GetCommandIdProperty(IUISimplePropertySet* propertySet)
 330 {
 331         PROPVARIANT var = { 0 };
 332         UINT32 commandId = 0;
 333
 334         if (propertySet->GetValue(UI_PKEY_CommandId, &var) == S_OK)
 335                 UIPropertyToUInt32(UI_PKEY_CommandId, var, &commandId);
 336
 337         return commandId;
 338 }
 339
 340 void CNativeRibbonApp::UpdateCmdUI(BOOL bDisableIfNoHandler)
 341 {
 342         for (auto it = m_commandIds.begin(); it != m_commandIds.end(); ++it)
 343         {
 344                 CRibbonCmdUI ui(*it);
 345                 ui.DoUpdate(m_pFrame, bDisableIfNoHandler);
 346                 if (ui.m_bEnableChanged)
 347                 {
 348                         PROPVARIANT val = { 0 };
 349                         UIInitPropertyFromBoolean(UI_PKEY_Enabled, ui.m_bOn, &val);
 350                         m_pFramework->SetUICommandProperty(*it, UI_PKEY_Enabled, val);
 351                 }
 352
 353                 if (ui.m_bCheckChanged)
 354                 {
 355                         PROPVARIANT val = { 0 };
 356                         UIInitPropertyFromBoolean(UI_PKEY_BooleanValue, ui.m_nCheck, &val);
 357                         m_pFramework->SetUICommandProperty(*it, UI_PKEY_BooleanValue, val);
 358                 }
 359         }
 360
 361         for (auto it = m_collectionCommandIds.begin(); it != m_collectionCommandIds.end(); ++it)
 362         {
 363                 PROPVARIANT currentValue = { 0 };
 364                 PROPVARIANT newValue = { 0 };
 365
 366                 UpdateProperty(*it, UI_PKEY_SelectedItem, &currentValue, &newValue);
 367                 m_pFramework->SetUICommandProperty(*it, UI_PKEY_SelectedItem, newValue);
 368         }
 369 }
 370
 371 int CNativeRibbonApp::GetRibbonHeight()
 372 {
 373         CComPtr<IUIRibbon> pRibbon;
 374         if (SUCCEEDED(m_pFramework->GetView(0, IID_PPV_ARGS(&pRibbon))))
 375         {
 376                 UINT32 cy = 0;
 377                 pRibbon->GetHeight(&cy);
 378                 return static_cast<int>(cy);
 379         }
 380
 381         return 0;
 382 }
 383
 384 class UIDynamicCommandItem : public IUISimplePropertySet
 385 {
 386 private:
 387         ULONG m_RefCount;
 388         CString m_Label;
 389         int m_CommandId;
 390         CComPtr<IUIImage> m_Image;
 391
 392 public:
 393         class UIDynamicCommandItem(int commandId, LPCWSTR label, IUIImage* image)
 394                 : m_RefCount(0)
 395                 , m_Label(label)
 396                 , m_CommandId(commandId)
 397                 , m_Image(image)
 398         {
 399         }
 400
 401         STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject)
 402         {
 403                 if (riid == __uuidof(IUnknown))
 404                 {
 405                         AddRef();
 406                         *ppvObject = static_cast<IUnknown*>(this);
 407                         return S_OK;
 408                 }
 409                 else if (riid == __uuidof(IUISimplePropertySet))
 410                 {
 411                         AddRef();
 412                         *ppvObject = static_cast<IUISimplePropertySet*>(this);
 413                         return S_OK;
 414                 }
 415                 return E_NOINTERFACE;
 416         }
 417
 418         STDMETHOD_(ULONG, AddRef)(void)
 419         {
 420                 return InterlockedIncrement(&m_RefCount);
 421         }
 422
 423         STDMETHOD_(ULONG, Release)(void)
 424         {
 425                 if (InterlockedDecrement(&m_RefCount) == 0)
 426                 {
 427                         delete this;
 428                         return 0;
 429                 }
 430                 return m_RefCount;
 431         }
 432
 433         STDMETHOD(GetValue)(REFPROPERTYKEY key, PROPVARIANT* value)
 434         {
 435                 if (key == UI_PKEY_Label)
 436                         return UIInitPropertyFromString(key, m_Label, value);
 437                 else if (key == UI_PKEY_CommandId)
 438                         return UIInitPropertyFromUInt32(UI_PKEY_CommandId, m_CommandId, value);
 439                 else if (key == UI_PKEY_ItemImage)
 440                         return UIInitPropertyFromInterface(UI_PKEY_ItemImage, m_Image, value);
 441                 return E_NOTIMPL;
 442         }
 443 };
 444
 445 void CNativeRibbonApp::SetItems(UINT cmdId, const std::list<CNativeRibbonDynamicItemInfo>& items)
 446 {
 447         CComPtr<IUICollection> uiCollection = GetUICommandItemsSource(cmdId);
 448         if (!uiCollection)
 449                 return;
 450
 451         CComPtr<IUIImageFromBitmap> imageFactory;
 452         imageFactory.CoCreateInstance(__uuidof(UIRibbonImageFromBitmapFactory));
 453
 454         UINT32 idx = 0;
 455         UINT32 count = 0;
 456         uiCollection->GetCount(&count);
 457         for (const auto & item : items)
 458         {
 459                 CComPtr<IUIImage> image;
 460                 if (imageFactory && item.GetImageId() > 0)
 461                 {
 462                         HBITMAP hbm = static_cast<HBITMAP>(LoadImage( AfxGetResourceHandle(), MAKEINTRESOURCE(item.GetImageId()), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION));
 463                         imageFactory->CreateImage(hbm, UI_OWNERSHIP_TRANSFER, &image);
 464                 }
 465
 466                 if (idx < count)
 467                         uiCollection->Replace(idx, new UIDynamicCommandItem(item.GetCommandId(), item.GetLabel(), image));
 468                 else
 469                         uiCollection->Add(new UIDynamicCommandItem(item.GetCommandId(), item.GetLabel(), image));
 470                 idx++;
 471         }
 472
 473         for (; idx < count; idx++)
 474         {
 475                 uiCollection->RemoveAt(idx);
 476         }
 477         SetUICommandItemsSource(cmdId, uiCollection);
 478 }