Diff to HTML by rtfpessoa

Files changed (4) hide show
  1. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Power.cpp +6 -17
  2. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Watermark.cpp +53 -16
  3. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Power.cpp +8 -16
  4. {baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Watermark.cpp +85 -23
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Power.cpp RENAMED
@@ -132,11 +132,11 @@ namespace ProxyStubs {
132
132
  // Exchange::IPower::INotification interface stub definitions
133
133
  //
134
134
  // Methods:
135
- // (0) virtual Core::hresult StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
135
+ // (0) virtual void StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
136
136
  //
137
137
 
138
138
  static ProxyStub::MethodHandler ExchangePowerNotificationStubMethods[] = {
139
- // (0) virtual Core::hresult StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
139
+ // (0) virtual void StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
140
140
  //
141
141
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
142
142
  Exchange::IPower::INotification* implementation = reinterpret_cast<Exchange::IPower::INotification*>(message->Parameters().Implementation());
@@ -147,10 +147,7 @@ namespace ProxyStubs {
147
147
  const Exchange::IPower::PCState _destination = reader.Number<Exchange::IPower::PCState>();
148
148
  const Exchange::IPower::PCPhase _phase = reader.Number<Exchange::IPower::PCPhase>();
149
149
 
150
- Core::hresult result = implementation->StateChange(_origin, _destination, _phase);
151
-
152
- RPC::Data::Frame::Writer writer(message->Response().Writer());
153
- writer.Number<Core::hresult>(result);
150
+ implementation->StateChange(_origin, _destination, _phase);
154
151
  }
155
152
  , nullptr
156
153
  }; // ExchangePowerNotificationStubMethods
@@ -284,7 +281,7 @@ namespace ProxyStubs {
284
281
  // Exchange::IPower::INotification interface proxy definitions
285
282
  //
286
283
  // Methods:
287
- // (0) virtual Core::hresult StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
284
+ // (0) virtual void StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
288
285
  //
289
286
 
290
287
  class ExchangePowerNotificationProxy final : public ProxyStub::UnknownProxyType<Exchange::IPower::INotification> {
@@ -294,7 +291,7 @@ namespace ProxyStubs {
294
291
  {
295
292
  }
296
293
 
297
- Core::hresult StateChange(const Exchange::IPower::PCState _origin, const Exchange::IPower::PCState _destination, const Exchange::IPower::PCPhase _phase) override
294
+ void StateChange(const Exchange::IPower::PCState _origin, const Exchange::IPower::PCState _destination, const Exchange::IPower::PCPhase _phase) override
298
295
  {
299
296
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
300
297
 
@@ -303,15 +300,7 @@ namespace ProxyStubs {
303
300
  writer.Number<Exchange::IPower::PCState>(_destination);
304
301
  writer.Number<Exchange::IPower::PCPhase>(_phase);
305
302
 
306
- Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
307
- if (hresult == Core::ERROR_NONE) {
308
- RPC::Data::Frame::Reader reader(message->Response().Reader());
309
- hresult = reader.Number<Core::hresult>();
310
- } else {
311
- ASSERT((hresult & COM_ERROR) != 0);
312
- }
313
-
314
- return (hresult);
303
+ static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
315
304
  }
316
305
 
317
306
  }; // class ExchangePowerNotificationProxy
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Debug/ThunderInterfaces/interfaces/generated/ProxyStubs_Watermark.cpp RENAMED
@@ -33,10 +33,11 @@ namespace ProxyStubs {
33
33
  // (4) virtual bool ShowWatermark(const bool) = 0
34
34
  // (5) virtual bool CreateWatermark(uint32_t, uint32_t) = 0
35
35
  // (6) virtual bool UpdateWatermark(uint32_t, uint32_t, uint32_t) = 0
36
- // (7) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
37
- // (8) virtual bool DeleteWatermark(uint32_t) = 0
38
- // (9) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
39
- // (10) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
36
+ // (7) virtual bool PersistLoadWatermark(uint32_t) = 0
37
+ // (8) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
38
+ // (9) virtual bool DeleteWatermark(uint32_t) = 0
39
+ // (10) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
40
+ // (11) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
40
41
  //
41
42
 
42
43
  static ProxyStub::MethodHandler ExchangeWatermarkStubMethods[] = {
@@ -168,7 +169,22 @@ namespace ProxyStubs {
168
169
  writer.Boolean(result);
169
170
  },
170
171
 
171
- // (7) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
172
+ // (7) virtual bool PersistLoadWatermark(uint32_t) = 0
173
+ //
174
+ [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
175
+ Exchange::IWatermark* implementation = reinterpret_cast<Exchange::IWatermark*>(message->Parameters().Implementation());
176
+ ASSERT(implementation != nullptr);
177
+
178
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
179
+ uint32_t _id = reader.Number<uint32_t>();
180
+
181
+ bool result = implementation->PersistLoadWatermark(_id);
182
+
183
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
184
+ writer.Boolean(result);
185
+ },
186
+
187
+ // (8) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
172
188
  //
173
189
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
174
190
  Exchange::IWatermark* implementation = reinterpret_cast<Exchange::IWatermark*>(message->Parameters().Implementation());
@@ -184,7 +200,7 @@ namespace ProxyStubs {
184
200
  writer.Boolean(result);
185
201
  },
186
202
 
187
- // (8) virtual bool DeleteWatermark(uint32_t) = 0
203
+ // (9) virtual bool DeleteWatermark(uint32_t) = 0
188
204
  //
189
205
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
190
206
  Exchange::IWatermark* implementation = reinterpret_cast<Exchange::IWatermark*>(message->Parameters().Implementation());
@@ -199,7 +215,7 @@ namespace ProxyStubs {
199
215
  writer.Boolean(result);
200
216
  },
201
217
 
202
- // (9) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
218
+ // (10) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
203
219
  //
204
220
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
205
221
  Exchange::IWatermark* implementation = reinterpret_cast<Exchange::IWatermark*>(message->Parameters().Implementation());
@@ -219,7 +235,7 @@ namespace ProxyStubs {
219
235
  writer.Text(result.clutType);
220
236
  },
221
237
 
222
- // (10) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
238
+ // (11) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
223
239
  //
224
240
  [](Core::ProxyType<Core::IPCChannel>& /* channel */, Core::ProxyType<RPC::InvokeMessage>& message) {
225
241
  Exchange::IWatermark* implementation = reinterpret_cast<Exchange::IWatermark*>(message->Parameters().Implementation());
@@ -281,10 +297,11 @@ namespace ProxyStubs {
281
297
  // (4) virtual bool ShowWatermark(const bool) = 0
282
298
  // (5) virtual bool CreateWatermark(uint32_t, uint32_t) = 0
283
299
  // (6) virtual bool UpdateWatermark(uint32_t, uint32_t, uint32_t) = 0
284
- // (7) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
285
- // (8) virtual bool DeleteWatermark(uint32_t) = 0
286
- // (9) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
287
- // (10) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
300
+ // (7) virtual bool PersistLoadWatermark(uint32_t) = 0
301
+ // (8) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
302
+ // (9) virtual bool DeleteWatermark(uint32_t) = 0
303
+ // (10) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
304
+ // (11) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
288
305
  //
289
306
 
290
307
  class ExchangeWatermarkProxy final : public ProxyStub::UnknownProxyType<Exchange::IWatermark> {
@@ -439,10 +456,30 @@ namespace ProxyStubs {
439
456
  return (result);
440
457
  }
441
458
 
442
- bool AdjustWatermark(uint32_t _id, uint32_t _zorder) override
459
+ bool PersistLoadWatermark(uint32_t _id) override
443
460
  {
444
461
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
445
462
 
463
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
464
+ writer.Number<uint32_t>(_id);
465
+
466
+ bool result{};
467
+
468
+ const Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
469
+ if (hresult == Core::ERROR_NONE) {
470
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
471
+ result = reader.Boolean();
472
+ } else {
473
+ ASSERT((hresult & COM_ERROR) != 0);
474
+ }
475
+
476
+ return (result);
477
+ }
478
+
479
+ bool AdjustWatermark(uint32_t _id, uint32_t _zorder) override
480
+ {
481
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(8));
482
+
446
483
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
447
484
  writer.Number<uint32_t>(_id);
448
485
  writer.Number<uint32_t>(_zorder);
@@ -462,7 +499,7 @@ namespace ProxyStubs {
462
499
 
463
500
  bool DeleteWatermark(uint32_t _id) override
464
501
  {
465
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(8));
502
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(9));
466
503
 
467
504
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
468
505
  writer.Number<uint32_t>(_id);
@@ -482,7 +519,7 @@ namespace ProxyStubs {
482
519
 
483
520
  Exchange::PalettedImageData GetPalettedWatermark(uint32_t _id) override
484
521
  {
485
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(9));
522
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(10));
486
523
 
487
524
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
488
525
  writer.Number<uint32_t>(_id);
@@ -507,7 +544,7 @@ namespace ProxyStubs {
507
544
 
508
545
  bool ModifyPalettedWatermark(uint32_t _id, Exchange::PalettedImageData _data) override
509
546
  {
510
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(10));
547
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(11));
511
548
 
512
549
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
513
550
  writer.Number<uint32_t>(_id);
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Power.cpp RENAMED
@@ -217,11 +217,11 @@ namespace ProxyStubs {
217
217
  // Exchange::IPower::INotification interface stub definitions
218
218
  //
219
219
  // Methods:
220
- // (0) virtual Core::hresult StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
220
+ // (0) virtual void StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
221
221
  //
222
222
 
223
223
  static ProxyStub::MethodHandler ExchangePowerNotificationStubMethods[] = {
224
- // (0) virtual Core::hresult StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
224
+ // (0) virtual void StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
225
225
  //
226
226
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
227
227
  Core::hresult hresult = Core::ERROR_NONE;
@@ -241,18 +241,14 @@ namespace ProxyStubs {
241
241
  if (reader.Length() < (Core::RealSize<Exchange::IPower::PCPhase>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
242
242
  const Exchange::IPower::PCPhase _phase = reader.Number<Exchange::IPower::PCPhase>();
243
243
 
244
- Core::hresult result = implementation->StateChange(_origin, _destination, _phase);
245
-
246
- RPC::Data::Frame::Writer writer(message->Response().Writer());
247
- writer.Number<Core::hresult>(result);
244
+ implementation->StateChange(_origin, _destination, _phase);
248
245
 
249
246
  return (Core::ERROR_NONE);
250
247
  } ();
251
248
 
252
249
  if (hresult != Core::ERROR_NONE) {
253
- RPC::Data::Frame::Writer writer(message->Response().Writer());
254
- writer.Number<uint32_t>(hresult);
255
250
  fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IPower::INotification::ID, 0, hresult);
251
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
256
252
  }
257
253
  }
258
254
  , nullptr
@@ -456,7 +452,7 @@ namespace ProxyStubs {
456
452
  // Exchange::IPower::INotification interface proxy definitions
457
453
  //
458
454
  // Methods:
459
- // (0) virtual Core::hresult StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
455
+ // (0) virtual void StateChange(const Exchange::IPower::PCState, const Exchange::IPower::PCState, const Exchange::IPower::PCPhase) = 0
460
456
  //
461
457
 
462
458
  class ExchangePowerNotificationProxy final : public ProxyStub::UnknownProxyType<Exchange::IPower::INotification> {
@@ -466,7 +462,7 @@ namespace ProxyStubs {
466
462
  {
467
463
  }
468
464
 
469
- Core::hresult StateChange(const Exchange::IPower::PCState _origin, const Exchange::IPower::PCState _destination, const Exchange::IPower::PCPhase _phase) override
465
+ void StateChange(const Exchange::IPower::PCState _origin, const Exchange::IPower::PCState _destination, const Exchange::IPower::PCPhase _phase) override
470
466
  {
471
467
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(0));
472
468
 
@@ -478,11 +474,8 @@ namespace ProxyStubs {
478
474
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
479
475
  if (hresult == Core::ERROR_NONE) {
480
476
  hresult = [&]() -> Core::hresult {
481
- RPC::Data::Frame::Reader reader(message->Response().Reader());
482
- if (reader.Length() < (Core::RealSize<Core::hresult>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
483
- hresult = reader.Number<Core::hresult>();
484
477
 
485
- return (hresult);
478
+ return (Core::ERROR_NONE);
486
479
  } ();
487
480
  } else {
488
481
  ASSERT((hresult & COM_ERROR) != 0);
@@ -490,9 +483,8 @@ namespace ProxyStubs {
490
483
 
491
484
  if ((hresult & COM_ERROR) != 0) {
492
485
  fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IPower::INotification::ID, 0, hresult);
486
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
493
487
  }
494
-
495
- return (hresult);
496
488
  }
497
489
 
498
490
  }; // class ExchangePowerNotificationProxy
{baseline/home/runner/work/ThunderTools/ThunderTools/ghpages_baseline/ProxyStubGenerator/master/latest_raw → generated/generated}/Release/ThunderInterfaces/interfaces/generated/ProxyStubs_Watermark.cpp RENAMED
@@ -38,10 +38,11 @@ namespace ProxyStubs {
38
38
  // (4) virtual bool ShowWatermark(const bool) = 0
39
39
  // (5) virtual bool CreateWatermark(uint32_t, uint32_t) = 0
40
40
  // (6) virtual bool UpdateWatermark(uint32_t, uint32_t, uint32_t) = 0
41
- // (7) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
42
- // (8) virtual bool DeleteWatermark(uint32_t) = 0
43
- // (9) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
44
- // (10) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
41
+ // (7) virtual bool PersistLoadWatermark(uint32_t) = 0
42
+ // (8) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
43
+ // (9) virtual bool DeleteWatermark(uint32_t) = 0
44
+ // (10) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
45
+ // (11) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
45
46
  //
46
47
 
47
48
  static ProxyStub::MethodHandler ExchangeWatermarkStubMethods[] = {
@@ -285,7 +286,37 @@ namespace ProxyStubs {
285
286
  }
286
287
  },
287
288
 
288
- // (7) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
289
+ // (7) virtual bool PersistLoadWatermark(uint32_t) = 0
290
+ //
291
+ [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
292
+ Core::hresult hresult = Core::ERROR_NONE;
293
+
294
+ hresult = [&]() -> Core::hresult {
295
+ if (message->Parameters().IsValid() == false) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
296
+
297
+ Exchange::IWatermark* implementation = reinterpret_cast<Exchange::IWatermark*>(message->Parameters().Implementation());
298
+ ASSERT(implementation != nullptr);
299
+ if (RPC::Administrator::Instance().IsValid(channel, RPC::instance_cast(implementation), Exchange::IWatermark::ID) == false) { return (COM_ERROR | Core::ERROR_NOT_EXIST); }
300
+
301
+ RPC::Data::Frame::Reader reader(message->Parameters().Reader());
302
+ if (reader.Length() < (Core::RealSize<uint32_t>())) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
303
+ uint32_t _id = reader.Number<uint32_t>();
304
+
305
+ bool result = implementation->PersistLoadWatermark(_id);
306
+
307
+ RPC::Data::Frame::Writer writer(message->Response().Writer());
308
+ writer.Boolean(result);
309
+
310
+ return (Core::ERROR_NONE);
311
+ } ();
312
+
313
+ if (hresult != Core::ERROR_NONE) {
314
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 7, hresult);
315
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
316
+ }
317
+ },
318
+
319
+ // (8) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
289
320
  //
290
321
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
291
322
  Core::hresult hresult = Core::ERROR_NONE;
@@ -312,12 +343,12 @@ namespace ProxyStubs {
312
343
  } ();
313
344
 
314
345
  if (hresult != Core::ERROR_NONE) {
315
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 7, hresult);
346
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 8, hresult);
316
347
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
317
348
  }
318
349
  },
319
350
 
320
- // (8) virtual bool DeleteWatermark(uint32_t) = 0
351
+ // (9) virtual bool DeleteWatermark(uint32_t) = 0
321
352
  //
322
353
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
323
354
  Core::hresult hresult = Core::ERROR_NONE;
@@ -342,12 +373,12 @@ namespace ProxyStubs {
342
373
  } ();
343
374
 
344
375
  if (hresult != Core::ERROR_NONE) {
345
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 8, hresult);
376
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 9, hresult);
346
377
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
347
378
  }
348
379
  },
349
380
 
350
- // (9) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
381
+ // (10) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
351
382
  //
352
383
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
353
384
  Core::hresult hresult = Core::ERROR_NONE;
@@ -377,12 +408,12 @@ namespace ProxyStubs {
377
408
  } ();
378
409
 
379
410
  if (hresult != Core::ERROR_NONE) {
380
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 9, hresult);
411
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 10, hresult);
381
412
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
382
413
  }
383
414
  },
384
415
 
385
- // (10) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
416
+ // (11) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
386
417
  //
387
418
  [](Core::ProxyType<Core::IPCChannel>& channel, Core::ProxyType<RPC::InvokeMessage>& message) {
388
419
  Core::hresult hresult = Core::ERROR_NONE;
@@ -422,7 +453,7 @@ namespace ProxyStubs {
422
453
  } ();
423
454
 
424
455
  if (hresult != Core::ERROR_NONE) {
425
- fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 10, hresult);
456
+ fprintf(stderr, "COM-RPC stub 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 11, hresult);
426
457
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
427
458
  }
428
459
  }
@@ -487,10 +518,11 @@ namespace ProxyStubs {
487
518
  // (4) virtual bool ShowWatermark(const bool) = 0
488
519
  // (5) virtual bool CreateWatermark(uint32_t, uint32_t) = 0
489
520
  // (6) virtual bool UpdateWatermark(uint32_t, uint32_t, uint32_t) = 0
490
- // (7) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
491
- // (8) virtual bool DeleteWatermark(uint32_t) = 0
492
- // (9) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
493
- // (10) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
521
+ // (7) virtual bool PersistLoadWatermark(uint32_t) = 0
522
+ // (8) virtual bool AdjustWatermark(uint32_t, uint32_t) = 0
523
+ // (9) virtual bool DeleteWatermark(uint32_t) = 0
524
+ // (10) virtual Exchange::PalettedImageData GetPalettedWatermark(uint32_t) = 0
525
+ // (11) virtual bool ModifyPalettedWatermark(uint32_t, Exchange::PalettedImageData) = 0
494
526
  //
495
527
 
496
528
  class ExchangeWatermarkProxy final : public ProxyStub::UnknownProxyType<Exchange::IWatermark> {
@@ -727,13 +759,12 @@ namespace ProxyStubs {
727
759
  return (result);
728
760
  }
729
761
 
730
- bool AdjustWatermark(uint32_t _id, uint32_t _zorder) override
762
+ bool PersistLoadWatermark(uint32_t _id) override
731
763
  {
732
764
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(7));
733
765
 
734
766
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
735
767
  writer.Number<uint32_t>(_id);
736
- writer.Number<uint32_t>(_zorder);
737
768
 
738
769
  bool result{};
739
770
 
@@ -758,12 +789,13 @@ namespace ProxyStubs {
758
789
  return (result);
759
790
  }
760
791
 
761
- bool DeleteWatermark(uint32_t _id) override
792
+ bool AdjustWatermark(uint32_t _id, uint32_t _zorder) override
762
793
  {
763
794
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(8));
764
795
 
765
796
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
766
797
  writer.Number<uint32_t>(_id);
798
+ writer.Number<uint32_t>(_zorder);
767
799
 
768
800
  bool result{};
769
801
 
@@ -788,13 +820,43 @@ namespace ProxyStubs {
788
820
  return (result);
789
821
  }
790
822
 
791
- Exchange::PalettedImageData GetPalettedWatermark(uint32_t _id) override
823
+ bool DeleteWatermark(uint32_t _id) override
792
824
  {
793
825
  IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(9));
794
826
 
795
827
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
796
828
  writer.Number<uint32_t>(_id);
797
829
 
830
+ bool result{};
831
+
832
+ Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
833
+ if (hresult == Core::ERROR_NONE) {
834
+ hresult = [&]() -> Core::hresult {
835
+ RPC::Data::Frame::Reader reader(message->Response().Reader());
836
+ if (reader.Length() < (1)) { return (COM_ERROR | Core::ERROR_READ_ERROR); }
837
+ result = reader.Boolean();
838
+
839
+ return (Core::ERROR_NONE);
840
+ } ();
841
+ } else {
842
+ ASSERT((hresult & COM_ERROR) != 0);
843
+ }
844
+
845
+ if ((hresult & COM_ERROR) != 0) {
846
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 9, hresult);
847
+ TRACE_L1("Warning: This COM-RPC failure will not propagate!");
848
+ }
849
+
850
+ return (result);
851
+ }
852
+
853
+ Exchange::PalettedImageData GetPalettedWatermark(uint32_t _id) override
854
+ {
855
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(10));
856
+
857
+ RPC::Data::Frame::Writer writer(message->Parameters().Writer());
858
+ writer.Number<uint32_t>(_id);
859
+
798
860
  Exchange::PalettedImageData result{};
799
861
 
800
862
  Core::hresult hresult = static_cast<const ProxyStub::UnknownProxy&>(*this).Invoke(message);
@@ -823,7 +885,7 @@ namespace ProxyStubs {
823
885
  }
824
886
 
825
887
  if ((hresult & COM_ERROR) != 0) {
826
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 9, hresult);
888
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 10, hresult);
827
889
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
828
890
  }
829
891
 
@@ -832,7 +894,7 @@ namespace ProxyStubs {
832
894
 
833
895
  bool ModifyPalettedWatermark(uint32_t _id, Exchange::PalettedImageData _data) override
834
896
  {
835
- IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(10));
897
+ IPCMessage message(static_cast<const ProxyStub::UnknownProxy&>(*this).Message(11));
836
898
 
837
899
  RPC::Data::Frame::Writer writer(message->Parameters().Writer());
838
900
  writer.Number<uint32_t>(_id);
@@ -859,7 +921,7 @@ namespace ProxyStubs {
859
921
  }
860
922
 
861
923
  if ((hresult & COM_ERROR) != 0) {
862
- fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 10, hresult);
924
+ fprintf(stderr, "COM-RPC call 0x%08x(%u) failed: 0x%08x\n", Exchange::IWatermark::ID, 11, hresult);
863
925
  TRACE_L1("Warning: This COM-RPC failure will not propagate!");
864
926
  }
865
927