libs/gtkmm2/gtk/gtkmm/printsettings.cc

   1 // Generated by gtkmmproc -- DO NOT MODIFY!
   2
   3
   4 #include <gtkmm/printsettings.h>
   5 #include <gtkmm/private/printsettings_p.h>
   6
   7 /* Copyright (C) 2006 The gtkmm Development Team
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the Free
  21  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <gtk/gtkprintsettings.h>
  25 #include <gtk/gtktypebuiltins.h>
  26
  27 #include <vector>
  28
  29 #include <glib/gmem.h>
  30
  31 namespace // anonymous
  32 {
  33
  34 static void proxy_foreach_callback(const gchar* key, const gchar* value, void* data)
  35 {
  36   typedef Gtk::PrintSettings::SlotForeach SlotType;
  37   SlotType& slot = *static_cast<SlotType*>(data);
  38
  39   #ifdef GLIBMM_EXCEPTIONS_ENABLED
  40   try
  41   {
  42   #endif //GLIBMM_EXCEPTIONS_ENABLED
  43     slot(Glib::convert_const_gchar_ptr_to_ustring(key), Glib::convert_const_gchar_ptr_to_ustring(value));
  44   #ifdef GLIBMM_EXCEPTIONS_ENABLED
  45   }
  46   catch(...)
  47   {
  48     Glib::exception_handlers_invoke();
  49   }
  50   #endif //GLIBMM_EXCEPTIONS_ENABLED
  51 }
  52
  53 } // anonymous namespace
  54
  55 namespace Gtk
  56 {
  57
  58 //Initialize static members:
  59 const Glib::ustring PrintSettings::Keys::PRINTER = GTK_PRINT_SETTINGS_PRINTER;
  60 const Glib::ustring PrintSettings::Keys::ORIENTATION = GTK_PRINT_SETTINGS_ORIENTATION;
  61 const Glib::ustring PrintSettings::Keys::PAPER_FORMAT = GTK_PRINT_SETTINGS_PAPER_FORMAT;
  62 const Glib::ustring PrintSettings::Keys::PAPER_WIDTH = GTK_PRINT_SETTINGS_PAPER_WIDTH;
  63 const Glib::ustring PrintSettings::Keys::PAPER_HEIGHT = GTK_PRINT_SETTINGS_PAPER_HEIGHT;
  64 const Glib::ustring PrintSettings::Keys::NUM_COPIES = GTK_PRINT_SETTINGS_N_COPIES;
  65 const Glib::ustring PrintSettings::Keys::DEFAULT_SOURCE = GTK_PRINT_SETTINGS_DEFAULT_SOURCE;
  66 const Glib::ustring PrintSettings::Keys::QUALITY = GTK_PRINT_SETTINGS_QUALITY;
  67 const Glib::ustring PrintSettings::Keys::RESOLUTION = GTK_PRINT_SETTINGS_RESOLUTION;
  68 const Glib::ustring PrintSettings::Keys::USE_COLOR = GTK_PRINT_SETTINGS_USE_COLOR;
  69 const Glib::ustring PrintSettings::Keys::DUPLEX = GTK_PRINT_SETTINGS_DUPLEX;
  70 const Glib::ustring PrintSettings::Keys::COLLATE = GTK_PRINT_SETTINGS_COLLATE;
  71 const Glib::ustring PrintSettings::Keys::REVERSE = GTK_PRINT_SETTINGS_REVERSE;
  72 const Glib::ustring PrintSettings::Keys::MEDIA_TYPE = GTK_PRINT_SETTINGS_MEDIA_TYPE;
  73 const Glib::ustring PrintSettings::Keys::DITHER = GTK_PRINT_SETTINGS_DITHER;
  74 const Glib::ustring PrintSettings::Keys::SCALE = GTK_PRINT_SETTINGS_SCALE;
  75 const Glib::ustring PrintSettings::Keys::PRINT_PAGES = GTK_PRINT_SETTINGS_PRINT_PAGES;
  76 const Glib::ustring PrintSettings::Keys::PAGE_RANGES = GTK_PRINT_SETTINGS_PAGE_RANGES;
  77 const Glib::ustring PrintSettings::Keys::PAGE_SET = GTK_PRINT_SETTINGS_PAGE_SET;
  78 const Glib::ustring PrintSettings::Keys::FINISHINGS = GTK_PRINT_SETTINGS_FINISHINGS;
  79 const Glib::ustring PrintSettings::Keys::NUMBER_UP = GTK_PRINT_SETTINGS_NUMBER_UP;
  80 const Glib::ustring PrintSettings::Keys::OUTPUT_BIN = GTK_PRINT_SETTINGS_OUTPUT_BIN;
  81
  82 const Glib::ustring PrintSettings::Keys::OUTPUT_FILE_FORMAT = GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT;
  83 const Glib::ustring PrintSettings::Keys::OUTPUT_URI = GTK_PRINT_SETTINGS_OUTPUT_URI;
  84
  85 const Glib::ustring PrintSettings::Keys::WIN32_DRIVER_VERSION = GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION;
  86 const Glib::ustring PrintSettings::Keys::WIN32_DRIVER_EXTRA = GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA;
  87
  88
  89 void PrintSettings::setting_foreach(const SlotForeach& slot)
  90 {
  91   SlotForeach slot_copy(slot);
  92   gtk_print_settings_foreach(const_cast<GtkPrintSettings*>(gobj()), &proxy_foreach_callback, &slot_copy);
  93 }
  94
  95 PrintSettings::PageRange::PageRange()
  96 :
  97   start(0),
  98   end(0)
  99 {}
 100
 101 PrintSettings::PageRange::PageRange(int start_, int end_)
 102 :
 103   start(start_),
 104   end(end_)
 105 {}
 106
 107 Glib::ArrayHandle<PrintSettings::PageRange> PrintSettings::get_page_ranges() const
 108 {
 109   int num_ranges;
 110   GtkPageRange* page_ranges =
 111     gtk_print_settings_get_page_ranges(const_cast<GtkPrintSettings*>(gobj()), &num_ranges);
 112   std::vector<PrintSettings::PageRange> v(num_ranges);
 113
 114   for (int i = 0; i < num_ranges; ++i)
 115   {
 116     v.push_back(PrintSettings::PageRange(page_ranges[i].start, page_ranges[i].end));
 117   }
 118
 119   g_free(page_ranges);
 120
 121   Glib::ArrayHandle<PrintSettings::PageRange> ah(v);
 122
 123   return ah;
 124 }
 125
 126 void PrintSettings::set_page_ranges(const Glib::ArrayHandle<PrintSettings::PageRange>& page_ranges)
 127 {
 128   int n = page_ranges.size();
 129   GtkPageRange* ranges = g_new0(GtkPageRange, n);
 130   std::vector<PrintSettings::PageRange> v_ranges(page_ranges);
 131
 132   for (int i = 0; i < n; ++i)
 133   {
 134     ranges[i].start = v_ranges[i].start;
 135     ranges[i].end = v_ranges[i].end;
 136   }
 137
 138   gtk_print_settings_set_page_ranges(const_cast<GtkPrintSettings*>(gobj()), ranges, n);
 139   g_free(ranges);
 140 }
 141
 142 void PrintSettings::save_to_key_file(Glib::KeyFile& key_file)
 143 {
 144   gtk_print_settings_to_key_file(gobj(), (key_file).gobj(), 0);
 145 }
 146
 147 } // namespace Gtk
 148
 149 namespace
 150 {
 151 } // anonymous namespace
 152
 153 // static
 154 GType Glib::Value<Gtk::PrintDuplex>::value_type()
 155 {
 156   return gtk_print_duplex_get_type();
 157 }
 158
 159 // static
 160 GType Glib::Value<Gtk::PrintQuality>::value_type()
 161 {
 162   return gtk_print_quality_get_type();
 163 }
 164
 165 // static
 166 GType Glib::Value<Gtk::PrintPages>::value_type()
 167 {
 168   return gtk_print_pages_get_type();
 169 }
 170
 171 // static
 172 GType Glib::Value<Gtk::PageSet>::value_type()
 173 {
 174   return gtk_page_set_get_type();
 175 }
 176
 177
 178 namespace Glib
 179 {
 180
 181 Glib::RefPtr<Gtk::PrintSettings> wrap(GtkPrintSettings* object, bool take_copy)
 182 {
 183   return Glib::RefPtr<Gtk::PrintSettings>( dynamic_cast<Gtk::PrintSettings*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
 184   //We use dynamic_cast<> in case of multiple inheritance.
 185 }
 186
 187 } /* namespace Glib */
 188
 189
 190 namespace Gtk
 191 {
 192
 193
 194 /* The *_Class implementation: */
 195
 196 const Glib::Class& PrintSettings_Class::init()
 197 {
 198   if(!gtype_) // create the GType if necessary
 199   {
 200     // Glib::Class has to know the class init function to clone custom types.
 201     class_init_func_ = &PrintSettings_Class::class_init_function;
 202
 203     // This is actually just optimized away, apparently with no harm.
 204     // Make sure that the parent type has been created.
 205     //CppClassParent::CppObjectType::get_type();
 206
 207     // Create the wrapper type, with the same class/instance size as the base type.
 208     register_derived_type(gtk_print_settings_get_type());
 209
 210     // Add derived versions of interfaces, if the C type implements any interfaces:
 211   }
 212
 213   return *this;
 214 }
 215
 216 void PrintSettings_Class::class_init_function(void* g_class, void* class_data)
 217 {
 218   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
 219   CppClassParent::class_init_function(klass, class_data);
 220
 221 #ifdef GLIBMM_VFUNCS_ENABLED
 222 #endif //GLIBMM_VFUNCS_ENABLED
 223
 224 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 225 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 226 }
 227
 228 #ifdef GLIBMM_VFUNCS_ENABLED
 229 #endif //GLIBMM_VFUNCS_ENABLED
 230
 231 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 232 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 233
 234
 235 Glib::ObjectBase* PrintSettings_Class::wrap_new(GObject* object)
 236 {
 237   return new PrintSettings((GtkPrintSettings*)object);
 238 }
 239
 240
 241 /* The implementation: */
 242
 243 GtkPrintSettings* PrintSettings::gobj_copy()
 244 {
 245   reference();
 246   return gobj();
 247 }
 248
 249 PrintSettings::PrintSettings(const Glib::ConstructParams& construct_params)
 250 :
 251   Glib::Object(construct_params)
 252 {}
 253
 254 PrintSettings::PrintSettings(GtkPrintSettings* castitem)
 255 :
 256   Glib::Object((GObject*)(castitem))
 257 {}
 258
 259 PrintSettings::~PrintSettings()
 260 {}
 261
 262
 263 PrintSettings::CppClassType PrintSettings::printsettings_class_; // initialize static member
 264
 265 GType PrintSettings::get_type()
 266 {
 267   return printsettings_class_.init().get_type();
 268 }
 269
 270 GType PrintSettings::get_base_type()
 271 {
 272   return gtk_print_settings_get_type();
 273 }
 274
 275
 276 PrintSettings::PrintSettings()
 277 :
 278   // Mark this class as non-derived to allow C++ vfuncs to be skipped.
 279   Glib::ObjectBase(0),
 280   Glib::Object(Glib::ConstructParams(printsettings_class_.init()))
 281 {
 282   }
 283
 284 Glib::RefPtr<PrintSettings> PrintSettings::create()
 285 {
 286   return Glib::RefPtr<PrintSettings>( new PrintSettings() );
 287 }
 288 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 289 bool PrintSettings::save_to_file(const std::string& file_name) const
 290 #else
 291 bool PrintSettings::save_to_file(const std::string& file_name, std::auto_ptr<Glib::Error>& error) const
 292 #endif //GLIBMM_EXCEPTIONS_ENABLED
 293 {
 294   GError* gerror = 0;
 295   bool retvalue = gtk_print_settings_to_file(const_cast<GtkPrintSettings*>(gobj()), file_name.c_str(), &(gerror));
 296 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 297   if(gerror)
 298     ::Glib::Error::throw_exception(gerror);
 299 #else
 300   if(gerror)
 301     error = ::Glib::Error::throw_exception(gerror);
 302 #endif //GLIBMM_EXCEPTIONS_ENABLED
 303
 304   return retvalue;
 305
 306 }
 307
 308 void PrintSettings::save_to_key_file(Glib::KeyFile& key_file, const Glib::ustring& group_name) const
 309 {
 310 gtk_print_settings_to_key_file(const_cast<GtkPrintSettings*>(gobj()), (key_file).gobj(), group_name.c_str());
 311 }
 312
 313 bool PrintSettings::has_key(const Glib::ustring& key) const
 314 {
 315   return gtk_print_settings_has_key(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
 316 }
 317
 318 Glib::ustring PrintSettings::get(const Glib::ustring& key) const
 319 {
 320   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get(const_cast<GtkPrintSettings*>(gobj()), key.c_str()));
 321 }
 322
 323 void PrintSettings::set(const Glib::ustring& key, const Glib::ustring& value)
 324 {
 325 gtk_print_settings_set(gobj(), key.c_str(), value.c_str());
 326 }
 327
 328 void PrintSettings::unset(const Glib::ustring& key)
 329 {
 330 gtk_print_settings_unset(gobj(), key.c_str());
 331 }
 332
 333 bool PrintSettings::get_bool(const Glib::ustring& key) const
 334 {
 335   return gtk_print_settings_get_bool(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
 336 }
 337
 338 void PrintSettings::set_bool(const Glib::ustring& key, bool value)
 339 {
 340 gtk_print_settings_set_bool(gobj(), key.c_str(), static_cast<int>(value));
 341 }
 342
 343 double PrintSettings::get_double(const Glib::ustring& key) const
 344 {
 345   return gtk_print_settings_get_double(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
 346 }
 347
 348 double PrintSettings::get_double_with_default(const Glib::ustring& key, double def) const
 349 {
 350   return gtk_print_settings_get_double_with_default(const_cast<GtkPrintSettings*>(gobj()), key.c_str(), def);
 351 }
 352
 353 void PrintSettings::set_double(const Glib::ustring& key, double value)
 354 {
 355 gtk_print_settings_set_double(gobj(), key.c_str(), value);
 356 }
 357
 358 double PrintSettings::get_length(const Glib::ustring& key, Unit unit) const
 359 {
 360   return gtk_print_settings_get_length(const_cast<GtkPrintSettings*>(gobj()), key.c_str(), ((GtkUnit)(unit)));
 361 }
 362
 363 void PrintSettings::set_length(const Glib::ustring& key, double value, Unit unit)
 364 {
 365 gtk_print_settings_set_length(gobj(), key.c_str(), value, ((GtkUnit)(unit)));
 366 }
 367
 368 int PrintSettings::get_int(const Glib::ustring& key) const
 369 {
 370   return gtk_print_settings_get_int(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
 371 }
 372
 373 int PrintSettings::get_int_with_default(const Glib::ustring& key, int def) const
 374 {
 375   return gtk_print_settings_get_int_with_default(const_cast<GtkPrintSettings*>(gobj()), key.c_str(), def);
 376 }
 377
 378 void PrintSettings::set_int(const Glib::ustring& key, int value)
 379 {
 380 gtk_print_settings_set_int(gobj(), key.c_str(), value);
 381 }
 382
 383 Glib::ustring PrintSettings::get_printer() const
 384 {
 385   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_printer(const_cast<GtkPrintSettings*>(gobj())));
 386 }
 387
 388 void PrintSettings::set_printer(const Glib::ustring& name)
 389 {
 390 gtk_print_settings_set_printer(gobj(), name.c_str());
 391 }
 392
 393 PageOrientation PrintSettings::get_orientation() const
 394 {
 395   return (PageOrientation)gtk_print_settings_get_orientation(const_cast<GtkPrintSettings*>(gobj()));
 396 }
 397
 398 void PrintSettings::set_orientation(PageOrientation orientation)
 399 {
 400 gtk_print_settings_set_orientation(gobj(), ((GtkPageOrientation)(orientation)));
 401 }
 402
 403 PaperSize PrintSettings::get_paper_size()
 404 {
 405   return Glib::wrap(gtk_print_settings_get_paper_size(gobj()), true);
 406 }
 407
 408 const PaperSize PrintSettings::get_paper_size() const
 409 {
 410   return const_cast<PrintSettings*>(this)->get_paper_size();
 411 }
 412
 413 void PrintSettings::set_paper_size(const PaperSize& paper_size)
 414 {
 415 gtk_print_settings_set_paper_size(gobj(), const_cast<GtkPaperSize*>((paper_size).gobj()));
 416 }
 417
 418 double PrintSettings::get_paper_width(Unit unit) const
 419 {
 420   return gtk_print_settings_get_paper_width(const_cast<GtkPrintSettings*>(gobj()), ((GtkUnit)(unit)));
 421 }
 422
 423 void PrintSettings::set_paper_width(double width, Unit unit)
 424 {
 425 gtk_print_settings_set_paper_width(gobj(), width, ((GtkUnit)(unit)));
 426 }
 427
 428 double PrintSettings::get_paper_height(Unit unit) const
 429 {
 430   return gtk_print_settings_get_paper_height(const_cast<GtkPrintSettings*>(gobj()), ((GtkUnit)(unit)));
 431 }
 432
 433 void PrintSettings::set_paper_height(double height, Unit unit)
 434 {
 435 gtk_print_settings_set_paper_height(gobj(), height, ((GtkUnit)(unit)));
 436 }
 437
 438 bool PrintSettings::get_use_color() const
 439 {
 440   return gtk_print_settings_get_use_color(const_cast<GtkPrintSettings*>(gobj()));
 441 }
 442
 443 void PrintSettings::set_use_color(bool use_color)
 444 {
 445 gtk_print_settings_set_use_color(gobj(), static_cast<int>(use_color));
 446 }
 447
 448 bool PrintSettings::get_collate() const
 449 {
 450   return gtk_print_settings_get_collate(const_cast<GtkPrintSettings*>(gobj()));
 451 }
 452
 453 void PrintSettings::set_collate(bool collate)
 454 {
 455 gtk_print_settings_set_collate(gobj(), static_cast<int>(collate));
 456 }
 457
 458 bool PrintSettings::get_reverse() const
 459 {
 460   return gtk_print_settings_get_reverse(const_cast<GtkPrintSettings*>(gobj()));
 461 }
 462
 463 void PrintSettings::set_reverse(bool reverse)
 464 {
 465 gtk_print_settings_set_reverse(gobj(), static_cast<int>(reverse));
 466 }
 467
 468 PrintDuplex PrintSettings::get_duplex() const
 469 {
 470   return (PrintDuplex)gtk_print_settings_get_duplex(const_cast<GtkPrintSettings*>(gobj()));
 471 }
 472
 473 void PrintSettings::set_duplex(PrintDuplex duplex)
 474 {
 475 gtk_print_settings_set_duplex(gobj(), ((GtkPrintDuplex)(duplex)));
 476 }
 477
 478 PrintQuality PrintSettings::get_quality() const
 479 {
 480   return (PrintQuality)gtk_print_settings_get_quality(const_cast<GtkPrintSettings*>(gobj()));
 481 }
 482
 483 void PrintSettings::set_quality(PrintQuality quality)
 484 {
 485 gtk_print_settings_set_quality(gobj(), ((GtkPrintQuality)(quality)));
 486 }
 487
 488 int PrintSettings::get_n_copies() const
 489 {
 490   return gtk_print_settings_get_n_copies(const_cast<GtkPrintSettings*>(gobj()));
 491 }
 492
 493 void PrintSettings::set_n_copies(int num_copies)
 494 {
 495 gtk_print_settings_set_n_copies(gobj(), num_copies);
 496 }
 497
 498 int PrintSettings::get_number_up() const
 499 {
 500   return gtk_print_settings_get_number_up(const_cast<GtkPrintSettings*>(gobj()));
 501 }
 502
 503 void PrintSettings::set_number_up(int number_up)
 504 {
 505 gtk_print_settings_set_number_up(gobj(), number_up);
 506 }
 507
 508 int PrintSettings::get_resolution() const
 509 {
 510   return gtk_print_settings_get_resolution(const_cast<GtkPrintSettings*>(gobj()));
 511 }
 512
 513 void PrintSettings::set_resolution(int resolution)
 514 {
 515 gtk_print_settings_set_resolution(gobj(), resolution);
 516 }
 517
 518 double PrintSettings::get_scale() const
 519 {
 520   return gtk_print_settings_get_scale(const_cast<GtkPrintSettings*>(gobj()));
 521 }
 522
 523 void PrintSettings::set_scale(double scale)
 524 {
 525 gtk_print_settings_set_scale(gobj(), scale);
 526 }
 527
 528 PrintPages PrintSettings::get_print_pages() const
 529 {
 530   return (PrintPages)gtk_print_settings_get_print_pages(const_cast<GtkPrintSettings*>(gobj()));
 531 }
 532
 533 void PrintSettings::set_print_pages(PrintPages print_pages)
 534 {
 535 gtk_print_settings_set_print_pages(gobj(), ((GtkPrintPages)(print_pages)));
 536 }
 537
 538 PageSet PrintSettings::get_page_set() const
 539 {
 540   return (PageSet)gtk_print_settings_get_page_set(const_cast<GtkPrintSettings*>(gobj()));
 541 }
 542
 543 void PrintSettings::set_page_set(PageSet page_set)
 544 {
 545 gtk_print_settings_set_page_set(gobj(), ((GtkPageSet)(page_set)));
 546 }
 547
 548 Glib::ustring PrintSettings::get_default_source() const
 549 {
 550   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_default_source(const_cast<GtkPrintSettings*>(gobj())));
 551 }
 552
 553 void PrintSettings::set_default_source(const Glib::ustring& default_source)
 554 {
 555 gtk_print_settings_set_default_source(gobj(), default_source.c_str());
 556 }
 557
 558 Glib::ustring PrintSettings::get_media_type() const
 559 {
 560   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_media_type(const_cast<GtkPrintSettings*>(gobj())));
 561 }
 562
 563 void PrintSettings::set_media_type(const Glib::ustring& media_type)
 564 {
 565 gtk_print_settings_set_media_type(gobj(), media_type.c_str());
 566 }
 567
 568 Glib::ustring PrintSettings::get_dither() const
 569 {
 570   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_dither(const_cast<GtkPrintSettings*>(gobj())));
 571 }
 572
 573 void PrintSettings::set_dither(const Glib::ustring& dither)
 574 {
 575 gtk_print_settings_set_dither(gobj(), dither.c_str());
 576 }
 577
 578 Glib::ustring PrintSettings::get_finishings() const
 579 {
 580   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_finishings(const_cast<GtkPrintSettings*>(gobj())));
 581 }
 582
 583 void PrintSettings::set_finishings(const Glib::ustring& finishings)
 584 {
 585 gtk_print_settings_set_finishings(gobj(), finishings.c_str());
 586 }
 587
 588 Glib::ustring PrintSettings::get_output_bin() const
 589 {
 590   return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_output_bin(const_cast<GtkPrintSettings*>(gobj())));
 591 }
 592
 593 void PrintSettings::set_output_bin(const Glib::ustring& output_bin)
 594 {
 595 gtk_print_settings_set_output_bin(gobj(), output_bin.c_str());
 596 }
 597
 598
 599 #ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 600 #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 601
 602 #ifdef GLIBMM_VFUNCS_ENABLED
 603 #endif //GLIBMM_VFUNCS_ENABLED
 604
 605
 606 } // namespace Gtk
 607
 608