libbonobo2-dev 2.32.1-0ubuntu5 / usr / share / gtk-doc / html / libbonobo / libbonobo-faq.html

This file is indexed.

/usr/share/gtk-doc/html/libbonobo/libbonobo-faq.html is in libbonobo2-dev 2.32.1-0ubuntu5.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Common Questions</title>
<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
<link rel="home" href="index.html" title="Libbonobo Reference Manual">
<link rel="up" href="misc.html" title="Miscellaneous">
<link rel="prev" href="debugging.html" title="Debugging">
<link rel="next" href="libbonobo-bonobo-config-database.html" title="bonobo-config-database">
<meta name="generator" content="GTK-Doc V1.19 (XML mode)">
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
<td><a accesskey="p" href="debugging.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
<td><a accesskey="u" href="misc.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
<th width="100%" align="center">Libbonobo Reference Manual</th>
<td><a accesskey="n" href="libbonobo-bonobo-config-database.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
</tr></table>
<div class="refentry">
<a name="libbonobo-faq"></a><div class="titlepage"></div>
<div class="refnamediv"><table width="100%"><tr>
<td valign="top">
<h2><span class="refentrytitle">Common Questions</span></h2>
<p>Common Questions — 
	    Find answers to common questions in the libbonobo manual
	</p>
</td>
<td valign="top" align="right"></td>
</tr></table></div>
<div class="refsect1">
<a name="id-1.8.3.3"></a><h2>Questions and Answers</h2>
<p>Miguel de Icaza (miguel@helixcode.com)</p>
<p>This is a work in progress.  Please mail me before
	    making any changes to this document.</p>
<div class="qandaset">
<a name="id-1.8.3.3.4"></a><table border="0" style="width: 100%;">
<colgroup>
<col align="left" width="1%">
<col>
</colgroup>
<tbody>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.1"></a><a name="id-1.8.3.3.4.1.1"></a><p><b>1.</b></p>
</td>
<td align="left" valign="top"><p>What is Bonobo?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> Bonobo is a component architecture for creating reusable
		    and distributed software components.  These software components
		    interact with each other through well defined interfaces which are
		    specified in the CORBA Interface Definition Language. </p>
<p> We distinguish between `Bonobo' the name of the component
			architecture, and `bonobo' which is the C-based easy to use
			implemenatation of the Bonobo component architecture.</p>
<p>The bonobo distribution consists of the following pieces:
			
			</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem"><p> The Bonobo interface definition files: these
				establish the standard interfaces used by Bonobo-based
				applications. </p></li>
<li class="listitem"><p>The core Bonobo runtime: Bonobo
				contains a rich API for dealing Bonobo Objects
				(activation for example).</p></li>
<li class="listitem">
<p> The GObject-Based (and hence C-based) Bonobo
				framework for creating new Bonobo::Unknown derived
				interfaces.  These are used to simplify the development of
				CORBA-servers using the C language binding.</p>
<p>Each derivative of a
				    <code class="classname">BonoboObject</code> implements an
				    interface derived from
				    <code class="literal">IDL:Bonobo/Unknown:1.0</code>.</p>
</li>
<li class="listitem"><p>A set of ready-to-use
				<code class="classname">BonoboObject</code>s derivatives that can
				be used in a variety of situations.  These are considered
				developer "sugar", although not required, they greatly
				simplify the development of Bonobo-based
				applications. </p></li>
<li class="listitem"><p> A set of "sugar" functions for
				manipulating client-side objects. </p></li>
</ul></div>
<p>
		    </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.2"></a><a name="id-1.8.3.3.4.2.1"></a><p><b>2.</b></p>
</td>
<td align="left" valign="top"><p> What is CORBA? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.3"></a><a name="id-1.8.3.3.4.3.1"></a><p><b>3.</b></p>
</td>
<td align="left" valign="top"><p> What is a component? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p> A component is a ( preferably small ), re-usable piece of
		    software, with well defined interfaces and interactions. In this
		    context these interfaces are described in IDL and the interactions
		    via. CORBA.  </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.4"></a><a name="id-1.8.3.3.4.4.1"></a><p><b>4.</b></p>
</td>
<td align="left" valign="top"><p> Is it possible to use Bonobo components in
		    my favorite language? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>You will need your favorite language to support
		    CORBA.</p>
<p> There are various CORBA implementations with a
			different degree of completness that you can use:
			</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem"><p>Owen Taylor has written Perl
				bindings for CORBA using ORBit. </p></li>
<li class="listitem"><p> James Henstridge
				has written Python binding for CORBA. </p></li>
<li class="listitem"><p> Dan Barlow has written Common
				Lisp bindings for CORBA. </p></li>
<li class="listitem"><p> C++ has piles of language
				bindings. </p></li>
</ul></div>
<p>
		    </p>
<p> You need your CORBA implementation to at least let you invoke
			methods on other CORBA objects as well as allowing you to
			implement CORBA objects.  Bonobo uses in various places callback
			mechanisms and these require the later functionality.  For
			instance, there is an old Emacs Lisp implementation that did not
			allow you to create CORBA object servers. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.5"></a><a name="id-1.8.3.3.4.5.1"></a><p><b>5.</b></p>
</td>
<td align="left" valign="top"><p>Are there other implementations of
		    Bonobo?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> There is a work in progress to implement Bonobo in other
		    languages, although most languages will want to reuse parts of the
		    core runtime to avoid duplicating a large piece of code that is better
		    kept centralized and reused.</p>
<p> FIXME: include a detailed list of the things that are
			conveniently not wrapped. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.6"></a><a name="id-1.8.3.3.4.6.1"></a><p><b>6.</b></p>
</td>
<td align="left" valign="top"><p> Is it possible to implement Bonobo components in language X?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>Yes.</p>
<p> First of all, it is important that your language has CORBA
			bindings, or that a suitable CORBA implementation is available for
			you.  You want if possible to get a CORBA 2.2 implementation, but this
			is not required. </p>
<p> It does not matter what language you are using, you can implement
			Bonobo Components by implementing the interface that your component
			wants to support. </p>
<p> Depending on your language, you will want to wrap
			some bits from Bonobo (for instance, the core runtime)
			or you will want to provide an alternate
			implementation or no implementation at all. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.7"></a><a name="id-1.8.3.3.4.7.1"></a><p><b>7.</b></p>
</td>
<td align="left" valign="top"><p>What is ORBit?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> ORBit is a CORBA implementation with a C mapping of
		    the CORBA 2.2 specification mostly written by Elliot Lee and Dick
		    Porter. </p>
<p> You can find more about ORBit <a class="ulink" href="http://www.labs.redhat.com/orbit" target="_top"> here </a> </p>
<p> ORBit is designed to be a small CORBA implementation that can
			be embedded in most applications on the desktop.  It also happens
			to be one of the fastest CORBA implementations in existance.  It
			supports a number of CORBA features:
			</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem"><p> C Language mapping. </p></li>
<li class="listitem"><p> A full POA implementation. </p></li>
<li class="listitem"><p> The Dynamic Invocation Interface. </p></li>
<li class="listitem"><p> The Dynamic Skeleton Interface. </p></li>
<li class="listitem"><p> CORBA Any values. </p></li>
<li class="listitem"><p> Typecodes. </p></li>
</ul></div>
<p>
		    </p>
<p> And it comes with a number of libraries that implement a few of
			the CORBA services (Cos) </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.8"></a><a name="id-1.8.3.3.4.8.1"></a><p><b>8.</b></p>
</td>
<td align="left" valign="top"><p> I am interested in CORBA, where can I learn more?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> CORBA is a standard published by the Object Management
		    Group, you can download various of their specifications from their
		    <a class="ulink" href="http://www.omg.org" target="_top"> web site </a> </p>
<p>See, for example, the <a class="ulink" href="http://www.omg.org/technology/documents/formal/c_language_mapping.htm" target="_top">C Language Mapping</a>.</p>
<p>FIXME: include pointers to more relevant documents.</p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.9"></a><a name="id-1.8.3.3.4.9.1"></a><p><b>9.</b></p>
</td>
<td align="left" valign="top"><p> What can I do with `bonobo'? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.10"></a><a name="id-1.8.3.3.4.10.1"></a><p><b>10.</b></p>
</td>
<td align="left" valign="top"><p>What is an OAFID?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>The OAFID is a unique identifier for a specific object
		    implementation and it is used to resolve uniquely.  This ID is used to
		    activate CORBA servers implementations. </p>
<p> For example, this OAFID represents the Gnumeric workbook
			factory object:
			</p>
<p><code class="literal">OAFIID:GNOME_Gnumeric_WorkbookFactory</code>
			</p>
<p>
		    </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.11"></a><a name="id-1.8.3.3.4.11.1"></a><p><b>11.</b></p>
</td>
<td align="left" valign="top"><p> What is a Factory? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p> A factory is an object that makes other
			objects. eg. a Gnumeric factory might make Workbook
			objects.</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.12"></a><a name="id-1.8.3.3.4.12.1"></a><p><b>12.</b></p>
</td>
<td align="left" valign="top"><p> Where does the OAFID come from? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.13"></a><a name="id-1.8.3.3.4.13.1"></a><p><b>13.</b></p>
</td>
<td align="left" valign="top"><p> What is a Control? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> A Control is a 'componentized' version of a
			Widget. ie. A Control is a (single view) Graphical
			component. </p>
<p> In the Gtk+ implementation a Control contains a
			GtkWidget, it also has associated 'properties',
			providing an easy way to customize basic features of
			the control without creating an idl interface. </p>
<p> A control is often used inside a BonoboWidget,
			which acts as a container of Controls. The
			BonoboWidget is a normal GtkWidget that can be
			inserted into a GtkContainer. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.14"></a><a name="id-1.8.3.3.4.14.1"></a><p><b>14.</b></p>
</td>
<td align="left" valign="top"><p> What is a PropertyBag, What is a Property? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p> See <a class="xref" href="properties.html" title="Properties"><span class="refentrytitle">Properties</span></a>. </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.15"></a><a name="id-1.8.3.3.4.15.1"></a><p><b>15.</b></p>
</td>
<td align="left" valign="top"><p> What are the activation methods in Bonobo? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> The prefered method of activating objects is through the
		    <code class="function">bonobo_get_object</code> function.  This one does
		    moniker based activation.  Like this: </p>
<p> For example this activates gnumeric and returns a
			<code class="classname">GNOME::Gnumeric::Worbook</code> CORBA
			object reference:</p>
<pre class="programlisting">
bonobo_get_object ("OAFIID:GNOME_Gnumeric_Workbook", "GNOME/Gnumeric/Workbook");
		    </pre>
<p> The following launches an image handler: </p>
<pre class="programlisting">
bonobo_get_object ("file:image.jpeg", "Bonobo/Control")
		    </pre>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.16"></a><a name="id-1.8.3.3.4.16.1"></a><p><b>16.</b></p>
</td>
<td align="left" valign="top"><p> Does Bonobo support in-proc components? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p> Yes, this depends on how you setup your component, however
			currently there are very few in-proc gnome components, due to
			various debugging problems. </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.17"></a><a name="id-1.8.3.3.4.17.1"></a><p><b>17.</b></p>
</td>
<td align="left" valign="top"><p>
		What is that long string of identifiers.</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.18"></a><a name="id-1.8.3.3.4.18.1"></a><p><b>18.</b></p>
</td>
<td align="left" valign="top"><p>
		Can you show me a simple Bonobo component?</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.19"></a><a name="id-1.8.3.3.4.19.1"></a><p><b>19.</b></p>
</td>
<td align="left" valign="top"><p>
		How can I write user interfaces with Glade?</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.20"></a><a name="id-1.8.3.3.4.20.1"></a><p><b>20.</b></p>
</td>
<td align="left" valign="top"><p>
		I want to pack a widget using Bonobo.</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.21"></a><a name="id-1.8.3.3.4.21.1"></a><p><b>21.</b></p>
</td>
<td align="left" valign="top"><p>Can I write GUI-less Bonobo components?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> Yes, you can.  Bonobo is in no way tied to the X11
			environment, although it fully supports it. </p>
<p> The C implementation of Bonobo uses
			<code class="classname">GObject</code>s as its base class, and hence you
			need to link against the glib-object libraries

			
			.
		    </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.22"></a><a name="id-1.8.3.3.4.22.1"></a><p><b>22.</b></p>
</td>
<td align="left" valign="top"><p> How can I write a configure script that detects Bonobo?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<pre class="programlisting">
PKG_CHECK_MODULES(BONOBO, libbonobo-2.0)
		    </pre>
<p> See <code class="literal">pkg-config(1)</code> for more details.</p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.23"></a><a name="id-1.8.3.3.4.23.1"></a><p><b>23.</b></p>
</td>
<td align="left" valign="top"><p>How do I compile and link a sample Bonobo application?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> If your source file is in the file component.c, you
			can compile it by using the following command line:</p>
<span class="command"><strong><code class="literal">cc `pkg-config --cflags libbonobo-2.0` -c component.c</code></strong></span><p> To link, you use the command line:</p>
<span class="command"><strong><code class="literal">cc `pkg-config --libs libbonobo-2.0` component.o</code></strong></span><p> You would replace <code class="literal">libbonobo-2.0</code>
			for <code class="literal">libbonoboui-2.0</code> if you are
			using the GUI/Gtk+ features of Bonobo and include
			<code class="literal">libgnomeprint-2.0</code> if you are using
			any of the printing facilities for components.</p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.24"></a><a name="id-1.8.3.3.4.24.1"></a><p><b>24.</b></p>
</td>
<td align="left" valign="top"><p> Where can I find examples of Bonobo use? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> There are various sample programs in the Bonobo distribution
			and they are mostly intended to either excercise a part of Bonobo
			or to show how a specific feature in Bonobo is
			implemented. </p>
<p> You can find the sample programs in bonobo/samples; A few
			simple components are in bonobo/components; There are various
			other test programs shipped with Bonobo as well (like gshell)
		    </p>
<p> For more advanced uses of Bonobo, you might want to look into
			Gnumeric, Nautilus or Evolution. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.25"></a><a name="id-1.8.3.3.4.25.1"></a><p><b>25.</b></p>
</td>
<td align="left" valign="top"><p> I noticed the lack of an IDispatch-like interface in
		    Bonobo, how do you cope with this problem? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> CORBA provides a better solution to IDispatch at the CORBA
			level which obviates the need to have something like that. </p>
<p> CORBA supports a mechanism on the client side called the
			Dynamic Invocation Interface (DII) which allows programmers to
			build their own CORBA request to a server. </p>
<p> On the server side CORBA supports the Dynamic Skeleton (or
			Server? FIXME) Interface which allows applications to decode
			arbitrary incoming CORBA requests. </p>
<p> Scripting languages would typically implement some sort of
			support for DII and DSI.  This enables scripting languages to talk
			to an arbitrary CORBA server or to implement any kind of CORBA
			interface. </p>
<p> Some CORBA bindings for scripting languages (like Owen Taylor's
			ORBit support for Perl) use the ORBs internals, as they are
			sometime easier to use than DII/DSI. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.26"></a><a name="id-1.8.3.3.4.26.1"></a><p><b>26.</b></p>
</td>
<td align="left" valign="top"><p>Can I write components in any language?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>You can write components in any language that has a CORBA
			binding or a CORBA implementation.  The only requirement is that
			your components implement one or more of the Bonobo
			interfaces.</p>
<p> The runtime for your language might want to reuse some of the C
			implementation features (like object activation, moniker
			activation and a few other utility functions).</p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.27"></a><a name="id-1.8.3.3.4.27.1"></a><p><b>27.</b></p>
</td>
<td align="left" valign="top"><p>Is Bonobo tied to the Gtk toolkit?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p>No, it is not.  The `bonobo' implementation is tied to Gtk+, but
			another binding for another language and another toolkit should be
			simple to write.</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.28"></a><a name="id-1.8.3.3.4.28.1"></a><p><b>28.</b></p>
</td>
<td align="left" valign="top"><p>Is Bonobo tied to the ORBit implementation?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p> We do not believe that Bonobo is tied to ORBit in any aspect,
			and there is even an implementation of Bonobo written in Java by
			Cactus (Gergo Erdi) called Monkeybeans that uses the Java
			ORB. </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.29"></a><a name="id-1.8.3.3.4.29.1"></a><p><b>29.</b></p>
</td>
<td align="left" valign="top"><p>What is a Moniker?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p>Monikers are used to name objects, they effectively
			implement an object naming space. The naming space is
			extremely abstract.
			
			Read doc/Monikers for a more in-depth explanation.</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.30"></a><a name="id-1.8.3.3.4.30.1"></a><p><b>30.</b></p>
</td>
<td align="left" valign="top"><p>Why are you so excited about Monikers?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p>Please read the bonobo/doc/Monikers document while I prepare
			the full answer.</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.31"></a><a name="id-1.8.3.3.4.31.1"></a><p><b>31.</b></p>
</td>
<td align="left" valign="top"><p>
		How can I write my own moniker? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.32"></a><a name="id-1.8.3.3.4.32.1"></a><p><b>32.</b></p>
</td>
<td align="left" valign="top"><p>
		Show me some examples. </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.33"></a><a name="id-1.8.3.3.4.33.1"></a><p><b>33.</b></p>
</td>
<td align="left" valign="top"><p>
		What is the POA? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.34"></a><a name="id-1.8.3.3.4.34.1"></a><p><b>34.</b></p>
</td>
<td align="left" valign="top"><p>
		Should I use the Bonobo "base classes"? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.35"></a><a name="id-1.8.3.3.4.35.1"></a><p><b>35.</b></p>
</td>
<td align="left" valign="top"><p> The memory management issues seem complex.
		What are the differences? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.36"></a><a name="id-1.8.3.3.4.36.1"></a><p><b>36.</b></p>
</td>
<td align="left" valign="top"><p>
		What does OAF do? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.37"></a><a name="id-1.8.3.3.4.37.1"></a><p><b>37.</b></p>
</td>
<td align="left" valign="top"><p>
		What is a name server? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.38"></a><a name="id-1.8.3.3.4.38.1"></a><p><b>38.</b></p>
</td>
<td align="left" valign="top"><p>
		Why would I want to use a Name Server? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.39"></a><a name="id-1.8.3.3.4.39.1"></a><p><b>39.</b></p>
</td>
<td align="left" valign="top"><p>
		I have my own needs for a name server,
		can I use it instead of yours? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.40"></a><a name="id-1.8.3.3.4.40.1"></a><p><b>40.</b></p>
</td>
<td align="left" valign="top"><p>
		Where are component properties stored? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.41"></a><a name="id-1.8.3.3.4.41.1"></a><p><b>41.</b></p>
</td>
<td align="left" valign="top"><p>
		What are the component properties? </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.42"></a><a name="id-1.8.3.3.4.42.1"></a><p><b>42.</b></p>
</td>
<td align="left" valign="top"><p> What kind of authentication system does Bonobo use for
		    its objects? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> Every CORBA object created by ORBit currently has a long and
			unique id created from a random sequence.  To contact this object
			it is necessary to have the full object reference in order to
			dispatch a request to it (typically the object reference is
			obtained from the name server, or you can get it in a stringified
			version as an IOR). </p>
<p> In the past, we used a cookie system that was attached to the
			object profile list (in a fully CORBA standard way) and this was
			used to authenticate the client and the server. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.43"></a><a name="id-1.8.3.3.4.43.1"></a><p><b>43.</b></p>
</td>
<td align="left" valign="top"><p> I notice that a port is open in my computer
		    for every application that creates CORBA object; is that
		    insecure?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>That port is created by ORBit to accept CORBA requests.  Before
			any request is processed by the ORB, the connection is
			authenticated (either by the use of the cookie mechanism, or
			because the IOR encodes a valid object reference). </p>
<p> There are no known holes or exploits known on the incoming
			request handler in ORBit and if you know of anyone, we would love
			to fix that problem. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.44"></a><a name="id-1.8.3.3.4.44.1"></a><p><b>44.</b></p>
</td>
<td align="left" valign="top"><p> Are communications between components in
		    Bonobo encrypted? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> We depend on the ORBit layer to do any kind of encryption of
			the data.  The current version of ORBit does not use SSL or any
			other secure transports, although patches for it are
			available. </p>
<p> FIXME: where are these patches available from? </p>
<p> The current version of ORBit (ORBit2) uses OpenSSL to provide
			encryption services. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.45"></a><a name="id-1.8.3.3.4.45.1"></a><p><b>45.</b></p>
</td>
<td align="left" valign="top"><p> If communications are not encrypted, why do you support
		    them? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top"><p> We guarantee that communications on the destkop are going to be
			secure, as nobody on the network will be able to sniff on your
			connections.  When you go over the network, then traffic is not
			encrypted and it might be subject to sniffing. </p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.46"></a><a name="id-1.8.3.3.4.46.1"></a><p><b>46.</b></p>
</td>
<td align="left" valign="top"><p>What is the problem with the standard C++ CORBA
		    binding?</p></td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.47"></a><a name="id-1.8.3.3.4.47.1"></a><p><b>47.</b></p>
</td>
<td align="left" valign="top"><p>What naming scheme should I use for my CORBA interfaces?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>If you are a GNOME/ project you need to register your
			GNOME/MyProject/ namespace, see bonobo/doc/NAMESPACE to see how
			these are allocated.</p>
<p>Otherwise, you should use a Java like namespacing scheme based
			on the DNS.</p>
<pre class="programlisting">
	module Com {
		module MyCompany {
			module MyProduct {
				interface MyInterface {
				};
			};
		};
	};
		    </pre>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.48"></a><a name="id-1.8.3.3.4.48.1"></a><p><b>48.</b></p>
</td>
<td align="left" valign="top"><p> How should I create unique OAFIIDs for components?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>There are two ways to do this. Firstly, those projects with a
			defined namespace that implement new interfaces. To create an
			OAFIID simply take your namespace, and with delimiting '_' create
			an IID within your own defined space eg.</p>
<p><code class="literal">OAFIID:GNOME_Evolution_Calendar_iTip_Factory</code></p>
<p><code class="literal">OAFIID:Com_MyCompany_MyProduct_Control</code></p>
<p> A suffix of the main function of the instance eg. _Control,
			_Factory, _Embeddable etc. is encouraged for clarity. </p>
<p> The second method for generating OAFIIDs is appropriate for
			small components that implement no new interfaces, and hence need
			no special namespace co-ordination. Namespace the initial portion
			as a category grouping eg. </p>
<p><code class="literal">OAFIID:GNOME_Panel_Applet_yetanotherclock:</code></p>
<p> and add a UUID generated from the uuidgen application at the
			end to garentee uniqueness. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.49"></a><a name="id-1.8.3.3.4.49.1"></a><p><b>49.</b></p>
</td>
<td align="left" valign="top"><p> What should I call my oaf / UI / IDL file ? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>The name of your oaf file should be based on your portion of the
			namespace, eg.</p>
<p><code class="literal">GNOME_Evolution_Calendar.oaf</code></p>
<p><code class="literal">Com_MyCompany_MyProduct.oaf</code></p>
<p>This ensures that there will be no conflicts installing oaf
			files into a common directory.</p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.50"></a><a name="id-1.8.3.3.4.50.1"></a><p><b>50.</b></p>
</td>
<td align="left" valign="top"><p>How should I name my CORBA methods ?</p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p>CORBA methods should be named using mixed caps, following a
			convention similar to that of Java convention. ie. method names
			should be verbs or verb phrases in mixed case with the first leter
			lowercase and the first letter of any further words
			capitalized.</p>
<pre class="programlisting">
interface MyInterface {

	long  getLength ();
	void  setLength (in long l);

	/* the ByName qualifier is a useful disambiguator */
	long  getValueByName (in string name);

	/* Factory methods should be named createWhatever */
	Bonobo::Unknown createObject ();

	/* Methods that test boolean conditions */
	boolean isDirty ();
	boolean hasLongLegs ();

	/* Mutator methods */	
	string toString ();
	double toDouble ();

	/* Signals */
	oneway void notifyRename ();

	/* Calculate a number of types */
	long countObjects (in Type t);
};
		    </pre>
<p> With acroyms we fully capitalize eg. <code class="literal">getURI</code>,
			with abbreviations and contractions we capitalize the first letter
			eg. <code class="literal">setDoc</code> <code class="literal">setId</code>. cf.
			<a class="ulink" href="http://java.sun.com/docs/books/jls/html/6.doc.html#11186" target="_top">http://java.sun.com/docs/books/jls/html/6.doc.html#11186</a>
		    </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.51"></a><a name="id-1.8.3.3.4.51.1"></a><p><b>51.</b></p>
</td>
<td align="left" valign="top"><p> How should I name attributes and structure members?
		    </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> Again, use a Java-like convention eg.</p>
<pre class="programlisting">
struct MyStructure {
	string theName;
	long   heightInInches;
};
		    </pre>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.52"></a><a name="id-1.8.3.3.4.52.1"></a><p><b>52.</b></p>
</td>
<td align="left" valign="top"><p> Why when I do a gtk_widget_show_all does my Control not
		    show up? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> The gtk_widget_show_all should not propagate over the plug /
			socket boundary, you need to ensure that you do a gtk_widget_show
			on your control. You can of course do shows / hides on the
			BonoboWidget ( the server side ) to show or hide the
			control. </p>
<p> This also means that as a component author, you are protected
			from people messing with your internal show / hide logic. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.53"></a><a name="id-1.8.3.3.4.53.1"></a><p><b>53.</b></p>
</td>
<td align="left" valign="top"><p> Aren't Monikers just a re-implementation of the GNOME
		    VFS?  Why not use the GNOME VFS? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> For a storage backend you can always use something like
			bonobo_storage_new ("gnome-vfs") and get away with life. </p>
<p> The main difference between the gnome-vfs, and monikers is that
			monikers are used to implement an object-based name space, while
			the gnome-vfs is a fine abstraction for naming files and
			directories.  The moniker space goes well beyond this. </p>
<p> When Ettore, Nat and I designed the GNOME VFS in Paris Ettore
			had a grander vision than Nat and I had.  Nat and I wanted exactly
			what the GNOME VFS is: an asyncronous, pluggable virtual file
			system implementation.  Ettore wanted something more general,
			something that would implement an object name space.  And some of
			the design decisions in the core of the gnome-vfs reflect some of
			this thinking, but the API and the infrastructure was limited to
			handling files. </p>
<p> Various months later, we finally understood completely the
			moniker system, and we realized that monikers were an object
			naming space, and that if done correctly monikers would be able to
			implement Ettore's initial vision for having an object-based
			naming space. </p>
</td>
</tr>
<tr class="question">
<td align="left" valign="top">
<a name="id-1.8.3.3.4.54"></a><a name="id-1.8.3.3.4.54.1"></a><p><b>54.</b></p>
</td>
<td align="left" valign="top"><p> When I run my program loads of daemons start and don't
		    stop, why? </p></td>
</tr>
<tr class="answer">
<td align="left" valign="top"></td>
<td align="left" valign="top">
<p> When you activate a Bonobo server the oaf daemon starts, this
			parses all your oafinfo files and then can respond to activation
			requests and queries. </p>
<p> The first access latency in this case is relatively high, the
			second access is extremely quick, consequently it is advantageous
			to leave the oafd process running on a GNOME system. Eventualy
			many of the GNOME desktop services will be using oaf regularly,
			making unloading it wasteful. </p>
<p> Most people are happy to have many daemons running on their
			machine - kswapd for example, or perhaps umpteen idle copies of
			mingetty - these are left running for performance reasons, and
			have a negligable impact on system performance. </p>
<p> Finally, patches are welcome to add a _user configurable_
			timeout and die option for those that begrudge the couple of Mb (
			including all dependant shlibs ) to oafd. The command oaf-slay can
			be used to kill all oaf servers at any time and one can profitably
			look for memory savings elsewhere. </p>
</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<div class="footer">
<hr>
          Generated by GTK-Doc V1.19</div>
</body>
</html>

APT Browse - Built by Thomas Orozco.