Extending a framework with CORBA
slide: Extending a framework with CORBA
 


  interface handler { 
   handler  

          event dispatch( in event data );
  	};
slide: handler
 


  interface event : handler { 
   event  

  
  	attribute long type;
  
  	attribute long x;
  	attribute long y;
  	};
slide: event
 


  interface kit : handler { 
   kit  

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


  interface widget : handler { 
   widget  

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


  interface item : handler { 
   item  

  
          void move( in long x, in long y );
  	};
slide: item
 


  interface iterator { 
   iterator  

          Object next();
  	};
slide: iterator
 


  interface container { 
   container  

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


  interface factory { 
   factory  

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


  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);
  };
slide: dot
 


  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);
  	};
  
  
  };
slide: module widgets

client 



      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);
          }
slide: A tk client
tk server">

server 



  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;
      }
  };
slide: The 


  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;
     }
slide: A tk application

client 



      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;
  	}
slide: Evaluating logical queries
 

  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;
  };
slide: A (remote) canvas client
 


  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;
  };
slide: A canvas server

server 



      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);
slide: Moving items