specialist.idl

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

	  case U2525F_left2: string left2;
	  case U2525F_left4: string left4;
	  case U2525F_right2: string right2;
	  case U2525F_right3: string right3;
	  case U2525F_right4: string right4;
	  case U2525F_bottom1: string bottom1;
	  case U2525F_nom_size: unsigned short nom_size;
	  case U2525F_min_size: unsigned short min_size;
	  case U2525F_max_size: unsigned short max_size;
	  case U2525F_scale: unsigned long scale;
	  case U2525F_is_hq: boolean is_hq;
	  case U2525F_rotate: float rotate;
	};
	struct E2525Symbol {
	    Graphic::EGraphic egraphic;
	    XYPoint p1;
	    LLPoint ll1;
	    string symbol;
	    char confirmed;
	    char reduced;
	    string movement;
	    string left2;
	    string left4;
	    string right1;
	    string right2;
	    string right3;
	    string right4;
	    string bottom1;
	    unsigned short nom_size;
	    unsigned short min_size;
	    unsigned short max_size;
	    unsigned long scale;
	    boolean is_hq;
	    float rotate;
	};
	E2525Symbol fill();
    };
    
    interface Rectangle : Graphic {
	attribute XYPoint p1;
	attribute XYPoint p2;
	attribute LLPoint ll1;
	attribute LLPoint ll2;

	enum settableFields {
	    RF_p1,
	    RF_p2,
	    RF_ll1,
	    RF_ll2
	};
	union RF_update switch (settableFields) {
	  case RF_p1: XYPoint p1;
	  case RF_p2: XYPoint p2;
	  case RF_ll1: LLPoint ll1;
	  case RF_ll2: LLPoint ll2;
	};
        struct ERectangle {
	    Graphic::EGraphic egraphic;
	    XYPoint p1;
	    XYPoint p2;
	    LLPoint ll1;
	    LLPoint ll2;
	};
	ERectangle fill();
    };
    
    interface Circle : Graphic {
	attribute XYPoint p1;
	attribute LLPoint ll1;
	attribute float major;
	attribute float minor;
	attribute unsigned short width;
	attribute unsigned short height;

	enum settableFields {
	    CF_p1,
	    CF_ll1,
	    CF_major,
	    CF_minor,
	    CF_width,
	    CF_height
	};
	union CF_update switch (settableFields) {
	  case CF_p1: XYPoint p1;
	  case CF_ll1: LLPoint ll1;
	  case CF_major: float major;
	  case CF_minor: float minor;
	  case CF_width: unsigned short width;
	  case CF_height: unsigned short height;
	};
        struct ECircle {
	    Graphic::EGraphic egraphic;
	    XYPoint p1;
	    LLPoint ll1;
	    float major;
	    float minor;
	    unsigned short width;
	    unsigned short height;
	  
	};
	ECircle fill();
    }; 

    interface Raster : Graphic {
	attribute XYPoint p1;
	attribute LLPoint ll1;
	attribute pixeldata pixels;
	attribute unsigned short width;
	attribute unsigned short height;
	attribute unsigned short x_hot;
	attribute unsigned short y_hot;
	attribute unsigned short colorsTotal;
	attribute colorTable ct;
	attribute unsigned short transparent;

	enum settableFields {
	    RASF_p1,
	    RASF_ll1,
	    RASF_pixels,
	    RASF_width,
	    RASF_height,
	    RASF_x_hot,
	    RASF_y_hot,
	    RASF_colorsTotal,
	    RASF_ct,
	    RASF_openColors,
	    RASF_transparent
	};
	union RASF_update switch (settableFields) {
	    case RASF_p1: XYPoint p1;
	    case RASF_ll1: LLPoint ll1;
	    case RASF_pixels: pixeldata pixels;
	    case RASF_width: unsigned short width;
	    case RASF_height: unsigned short height;
	    case RASF_x_hot: unsigned short x_hot;
	    case RASF_y_hot: unsigned short y_hot;
	    case RASF_colorsTotal: unsigned short colorsTotal;
	    case RASF_ct: colorTable ct;
	    case RASF_transparent: unsigned short transparent;
	};
	struct ERaster {
	    Graphic::EGraphic egraphic;
	    XYPoint p1;
	    LLPoint ll1;
            pixeldata pixels;
            unsigned short width;
            unsigned short height;
	    unsigned short x_hot;
	    unsigned short y_hot;
            unsigned short colorsTotal;
            colorTable ct;
            unsigned short transparent;
	};
	ERaster fill();
    };

    interface ForceArrow : Graphic {

	attribute XYPoint p1;
	attribute XYPoint p2;
	attribute XYPoint p3;
	attribute LLPoint ll1;
	attribute LLPoint ll2;
	attribute LLPoint ll3;
	attribute LLPoint offset;

	enum settableFields {
	    FAF_p1,
	    FAF_p2,
	    FAF_p3,
	    FAF_ll1,
	    FAF_ll2,
	    FAF_ll3,
	    FAF_offset
	};
	union FAF_update switch (settableFields) {
	  case FAF_p1: XYPoint p1;
	  case FAF_p2: XYPoint p2;
	  case FAF_p3: XYPoint p3;
	  case FAF_ll1: LLPoint ll1;
	  case FAF_ll2: LLPoint ll2;
	  case FAF_ll3: LLPoint ll3;
	  case FAF_offset: LLPoint offset;
	};
        struct EForceArrow {
	    Graphic::EGraphic egraphic;
	    XYPoint p1;
	    XYPoint p2;
	    XYPoint p3;
	    LLPoint ll1;
	    LLPoint ll2;
	    LLPoint ll3;
	    LLPoint offset;
	};
	EForceArrow fill();
    };
    
    union UGraphic switch (Graphic::GraphicType) {
      case Graphic::GT_Bitmap: Bitmap::EBitmap ebit;
      case Graphic::GT_Text: Text::EText etext;
      case Graphic::GT_Poly: Poly::EPoly epoly;
      case Graphic::GT_Line: Line::ELine eline;
      case Graphic::GT_UnitSymbol: UnitSymbol::EUnitSymbol eunit;
      case Graphic::GT_2525Symbol: U2525Symbol::E2525Symbol e2525;
      case Graphic::GT_Rectangle: Rectangle::ERectangle erect;
      case Graphic::GT_Circle: Circle::ECircle ecirc;
      case Graphic::GT_Raster: Raster::ERaster eras;
      case Graphic::GT_ForceArrow: ForceArrow::EForceArrow efarrow;
    };
    typedef sequence<UGraphic> UGraphicSeq;

    enum ReorderType {
      RT_Raise,		// Like doing a RaiseGraphic callback
      RT_Lower,		// Like doing a LowerGraphic callback
      RT_Delete		// Remove graphic from drawing list
    };
      
    union UpdateGraphic switch (Graphic::GraphicType) {
      case Graphic::GT_Graphic: Graphic::GF_update gf_update;
      case Graphic::GT_Bitmap: Bitmap::BF_update bf_update;
      case Graphic::GT_Text: Text::TF_update tf_update;
      case Graphic::GT_Poly: Poly::PF_update pf_update;
      case Graphic::GT_Line: Line::LF_update lf_update;
      case Graphic::GT_UnitSymbol: UnitSymbol::USF_update usf_update;
      case Graphic::GT_2525Symbol: U2525Symbol::U2525F_update u2525f_update;
      case Graphic::GT_Rectangle: Rectangle::RF_update rf_update;
      case Graphic::GT_Circle: Circle::CF_update cf_update;
      case Graphic::GT_Raster: Raster::RASF_update rasf_update;
      case Graphic::GT_ForceArrow: ForceArrow::FAF_update faf_update;
      case Graphic::GT_NewGraphic: UGraphic new_graphic;
      case Graphic::GT_ReorderGraphic: ReorderType reorder_kind;
    };
    typedef sequence<UpdateGraphic> UpdateGraphicSeq;
    struct UpdateRecord {
	string gID;
	UpdateGraphicSeq objectUpdates;
    };
    typedef sequence<UpdateRecord> GUpdate;

    //------------------------------------------------------------
    //  Gesture Unions
    //------------------------------------------------------------

    enum MouseType {
      ClickEvent,
      MotionEvent,
      KeyEvent,
      MapViewChangeEvent
    };

    struct key_modifiers {
      boolean alt;
      boolean shift;
      boolean control;
    };
	
    struct Mouse {
      XYPoint point;
      LLPoint llpoint;
      unsigned short mousebutton;
      boolean press;  //true for press, false for release
      key_modifiers modifiers;
    };

    struct Keypress {
      XYPoint point;
	//LLPoint llpoint;  implement for consistency?
      char key;
      key_modifiers modifiers;
    };

    struct MapViewHolder{
	//This is not currently used for anything
	LLPoint nwcorner;
	LLPoint secorner;
    };
    
    union MouseEvent switch (MouseType) {
      case ClickEvent: Mouse click;
      case MotionEvent: Mouse motion;
      case KeyEvent: Keypress keypress;
      case MapViewChangeEvent: MapViewHolder mapviewchange;
    };

    enum ActionType {
      UpdateGraphics,		// Update screen graphics
      UpdatePalette,		// Update the layer's palette
      InfoText,			// Display info on browser status line
      PlainText,		// Display additional text info (non-html)
      HTMLText,			// Display additional text info (HTML)
      URL			// Send web browser to a URL
    };

    union ActionUnion switch (ActionType) {
      case UpdateGraphics: GUpdate ginfo;
      case InfoText: string itext;
      case PlainText: string ptext;
      case HTMLText: string htext;
	//case UpdatePalette: PUpdate pinfo;
      case URL: string url;
    };
      
    // Don't put more than 1 thing of each type in the sequence...
    typedef sequence<ActionUnion> ActionSeq;

    // ----------------------------------------------------------------------
    // Gesture Interfaces
    //
    //  Gestures can happen on graphics or on the map (the Server
    //  object declared later). 
    // ----------------------------------------------------------------------

    interface Comp {
	ActionSeq sendGesture(in MouseEvent gesture, in string uniqueID);
	readonly attribute string cID;
	EComp fill();
    };
    
    interface InfoComp : Comp {
	readonly attribute string info;
	readonly attribute string iurl;
	readonly attribute string ptext;
	readonly attribute string htext;
    };
    


    // ----------------------------------------------------------------------
    //  Palette Widget Interfaces
    // ----------------------------------------------------------------------
    
    struct CheckButton
    {
      string button_label;
      boolean checked;
    };
    typedef sequence<CheckButton> CheckButtons;
    interface CheckBox;
    interface CheckBox
      {
	attribute string label;
	attribute CheckButtons buttons;
	oneway void selected(in string box_label, 
		      in CheckButton button, in string uniqueID);
      };

    interface RadioBox;
    interface RadioBox
      {
	attribute string label;
	attribute strings buttons;
	attribute string selected_button;
	oneway void selected(in string box_label, 
		      in string selected_button, 
		      in string uniqueID);
      };

    interface ListBox;
    interface ListBox
      {
	attribute string label;
	attribute strings contents;
	attribute string highlighted_item;  
	oneway void selected(in string box_label, 
		      in string selected_item, in string uniqueID);
      };

    interface ButtonBox;
    interface ButtonBox
     {
       attribute string label;
       attribute strings buttons;
       oneway void pressed(in string box_label, 
		    in string button_pressed, in string uniqueID);
     };
  
    interface Slider;
    interface Slider
     {
       attribute string label;
       attribute short start;
       attribute short end;
       attribute short value; //initial position, between start and end
       attribute boolean vertical;
       oneway void set(in string label, in short new_setting, in string uniqueID);
     };

    interface TextBox;
    interface TextBox
    {
      attribute string label;
      attribute string contents;
      oneway void pressed(in string box_label,
		   in string new_contents, in string uniqueID);
    };

    enum WidgetType
    {
      WT_CheckBox,
      WT_RadioBox,
      WT_Slider,
      WT_ButtonBox,
      WT_ListBox,
      WT_TextBox
    };

    union UWidget switch (WidgetType)
    {
       case WT_CheckBox: CheckBox cb;
       case WT_RadioBox: RadioBox rb;
       case WT_Slider:   Slider slide;
       case WT_ButtonBox:ButtonBox bb;
       case WT_ListBox:  ListBox lb;
       case WT_TextBox:  TextBox tb;
    };

    typedef sequence<UWidget> UWidgetSeq;
    

    // ----------------------------------------------------------------------
    //  Notify interfaces - (mattserver callbacks)
    // ----------------------------------------------------------------------
    interface GraphicChange {
	//gives the mattserver a list of graphics that it needs to refetch
	oneway void ChangeNotify(in boolean forceRedraw, in strings gIDseq);

	//tells the mattserver to forget about everything it had (so
	//when it redraws, to do a new fillrectangle call)
	oneway void ForgetAll(in boolean forceRedraw);

	//changes the ordering of graphics
	oneway void RaiseGraphic(in boolean forceRedraw, in strings gIDseq);
	oneway void LowerGraphic(in boolean forceRedraw, in strings gIDseq);

	//tells the mattserver about specific changes to the graphic
	//i.e. change fillcolor to blus
	oneway void SetClientAttributes(in boolean forceRedraw,
					in GUpdate info);

	//like _IT_PING(), but can be done asynchronously
	//which means it doesn't do anything generally useful
	void ping();
    };
    
    interface WidgetChange
      {
	//tells the mattserver to forget about the current palette (so
	//it will do a new getPaletteConfig() call)
       oneway void ForgetAll(in boolean forceRedo);
      };

    //------------------------------------------------------------
    //  Server methods
    //------------------------------------------------------------

    interface Server {
	// the specialist server maintains unique objects per
	// unique host:pid:layer context
	UGraphicSeq getRectangle (
	    in CProjection p, in LLPoint ll1, in LLPoint ll2,
	    in string staticArgs, inout string dynamicArgs,
	    // setup for gestures
	    out short graphicSeletableDistance,
	    out boolean areaEvents,
	    // callback interface
	    in GraphicChange notifyOnChange,
	    // mattserver ID
	    in string uniqueID);

	ActionSeq sendGesture(in MouseEvent gesture, in string uniqueID);

	// alerts specialist server that objects are no
	// longer needed for context host:pid:layer
	oneway void signoff(in string uniqueID);

	UWidgetSeq getPaletteConfig(in WidgetChange notifyOnChange,
				    in string staticArgs,
				    inout string dynamicArgs,
				    in string uniqueID);
    };
};

#endif