Crush -- extending hush with CORBA

For giving access to objects within a particular hush component, we have provided dots (distributed object tables) for both hush and the widgets components. Using the dot the client can access an object of a given type by the name it is given by the server. The object must already exist in the server.

In case clients are allowed to create objects within the server, a factory is provided for creating hush or widget objects.

Client-side adaptors

To allow clients the use of CORBA IDL classes wherever one of the original hush classes is expected, client-side adaptors have been provided for each of the hush or widgets IDL classes. An additional advantage of client-side adaptors is that they allow for overcoming the `weaknesses' of IDL with respect to overloading member functions, parametrized types and operator definitions.

Typically, client-side adaptors have their corresponding hush class as a base class and simply delegate method invocations to the CORBA object they encapsulate.

Events versus object method invocation

Nevertheless, in our opinion events should be used in a very restricted manner. Events tend to break the `crisp' object interfaces that are one of the benefits of an object-oriented approach to design.

For the hush CORBA extensions, we have chosen for retaining the original hush object interfaces. Note however that the IDL interfaces are somewhat more abstract than the corresponding C++ interfaces. Nevertheless, the event interface is part of the hush module. Together with the dispatch function of the handler interface incoming events resulting from user actions may be dispatched directly to remote components.

Interfaces

  interface handler { 
   handler  


          event dispatch( in event data );
  	};
  

  interface event : handler { 
   event  


  
  	attribute long type;
  
  	attribute long x;
  	attribute long y;
  	};
  

  interface kit : handler { 
   kit  


  
  	void source(in string file);
  	void eval(in string command);
  	string result();
  
  	widget root();
  	};
  

  interface widget : handler { 
   widget  


  
     string path();
  
     void eval( in string cmd );
  
     void configure( in string options );
     void pack( in string options );
  };
  

  interface item : handler { 
   item  


  
          void move( in long x, in long y );
  	};
  

  interface iterator { 
   iterator  


          Object next();
  	};
  

  interface container { 
   container  


  
          long length();
  
          Object first();
          Object next();
          Object current();
  
          iterator walk();
  	};
  

  interface factory { 
   factory  


  
          hush::kit kit(in string name);
          hush::event event(in long type);
  };
  

  interface dot {  
   dot  


  
          hush::kit kit(in string name);
  
          hush::container container(in string name);
          hush::iterator iterator(in string name);
  
          hush::factory hush(in string name);
  };
  

  module widgets {
  
  interface canvas : hush::widget { 
   canvas  


  
  	canvas create( in hush::widget anc, in string path );
  
  	hush::item circle( in long x, in long y, in long radius, in string options );
  	// other items ...
  	};
  
  
  
  
  interface message : hush::widget { 
   message  


  
  	message create( in hush::widget anc, in string path );
  	void text(in string txt);
  	};
  
  
  
  
  interface factory : hush::factory { 
   factory  


  
   	widgets::canvas  canvas(in string name, in string options);
   	widgets::message message(in string name, in string options);
  	};
  
  
  
  interface dot : hush::dot {  
   dot  


  
  	widgets::canvas  canvas(in string name);
  	widgets::message message(in string name);
  
  	widgets::factory widgets(in string name);
  	};
  
  
  };
  

      hush::dot*      hush;      // (distributed) object tables
      widgets::dot*   widgets;   // widgets contains hush
  
      hush::kit* tk;             // remote kit object
      widgets::message* banner;
  
      try {
          hush = widgets = widgets::dot::_bind (SERVER, argv[1]);
  
          tk = hush->kit("tk");
          banner = widgets->message("hello"); // must exist
  
      } catch (...) {
           cerr << "Unexpected exception ..." << endl;
           return -1;
      }
  
  
  
      while (1) {
  	char text = readtext(); // from stdin
  	
  	banner->text( text );  // display text
  	tk->eval(text);
          }
  

  class application : public session {
  public:
  application(int argc, char* argv[]) : session(argc,argv,"hello") {
  }
  void corba();
  int main() {
      tk->trace();
      kit::declare("tk",tk);
  
      message* m = new hello(".hello"); 
      m->pack();
  
      message::declare("hello",m);
  
      corba(); // make yourself available as a server
  
      return OK;
      }
  };
  

  void application::corba() {
  
  widgets::dot* dw = new widgets_dot_srv(); // create dot for widgets
  
  try {
   CORBA::Orbix.registerIOCallback(it_orbix_fd_open, FD_OPEN_CALLBACK);
   CORBA::Orbix.registerIOCallback(it_orbix_fd_close, FD_CLOSE_CALLBACK);
  
   CORBA::Orbix.impl_is_ready(SERVER,0);
   CORBA::Orbix.processEvents(0);
   }
  catch (...) {
       cout << "apparently something went wrong" << endl;
     }
  

      try {
  
          tk = hush->kit("bp");       // A kit for BinProlog
          tk->eval("consult(facts)");
          }
      catch(...) {
          cout << "An exception ... " << endl;
      }
  
      while (1) {
          char* text = readtext();
          tk->eval(text);
          char* q = 0;
          while ( (q = tk->result()) )
                  cout << "Result: " << q << endl;
  	}
  

  class draw_clt : public canvas {  
   draw_clt  


  public:
  
  void plug(widgets::canvas* x) { draw = x; }
  
  int operator()() {
          hush::event* e = hush->event(_event->type());
          cerr << "Getting event " << e->type() << endl;
          e->x(_event->x()+10);
          e->y(_event->y()+10);
          hush::event::_duplicate(e);  // CORBA 2.0
          hush::event* res = draw->dispatch(e);
          return canvas::operator()();
          }
  
  
  
  draw_clt(const widget* w,  char* path ) : canvas(w,path) {  
          configure("-background white");
          geometry(200,100);
          self()->bind(this);
          dragging = 0;
  }
  
  draw_clt(char* path ) : canvas(path) { 
          configure("-background white");
          geometry(200,100);
          self()->bind(this);
          dragging = 0;
  }
  
  
  void press( event& ) { dragging = 1; }
  
  void motion( event& e) { 
          if (dragging) {
                  self()->circle(e.x(),e.y(),2,"-fill black");
                  draw->circle(e.x(),e.y(),3,"-fill yellow");
                  }
  }
  
  void release( event&  ) { dragging = 0; }
  
  protected:
  int dragging;
  widgets::canvas* draw;
  };
  

  class draw_srv : public canvas { 
   draw_srv    


  public:
  
  draw_srv( const widget* w,  char* path ) : canvas(w,path) {  
          geometry(200,100);
          self()->bind(this);
          dragging = 0;
  }
  
  void press( event& ) { dragging = 1; }
  
  void motion( event& e) { 
          if (dragging) circle(e.x(),e.y(),10,"-fill black");
  }
  
  void release( event&  ) { dragging = 0; }
  
  protected:
  int dragging;
  };
  

      list* rlist =  new list;
      item* it = draw->circle(40,40,10,"-fill yellow");
      hush::item* rit = new item_srv(it);
      rlist->insert(rit);
      it = draw->circle(30,30,10,"-fill red");
      rit = new item_srv(it);
      rlist->insert(rit);
  
      hush::container* rx = new list_srv(rlist);
      list::declare("items",rx); // store server
  
      iter* riter = rlist->walk();
      iter::declare("riter",riter);