ObjectGears Help

           
Forum   ObjectGears (Version: 1.6.0.0)

Definition of webparts in modules

In order to add a webpart into the module implement in the class ModuleInterface overloading of method GetWebPartInfos(), that returns collection WPInfoList with definition of your webparts. Number of webparts is not limited.

Create a child class of the class WPInfo for each webpart and insert it into the collection. This child is responsible for creation of the webpart instance and control element for webpart configuration.

 

public class ModuleInterface : ModuleInterfaceBase
{
    ...

    public override WPInfoList GetWebPartInfos()
    {
        WPInfoList l = new WPInfoList();

        l.Add( new MenuWPInfo(this));

        return l;
    }
}


    public class MenuWPInfo : WPInfo
    {
        public readonly Guid gwpMenu = new Guid("{  ENTER A NEW GUID FOR WEBPART  }");

        private ModuleInterface module;

        public MenuWPInfo(ModuleInterface module) : base( new MenuWebPart())
        {
            this.module = module;
            InfoId = gwpMenu;
        }

        public override WebPartBase GetWebPartInstance(ContentPage cp, WPBase wp, bool isDesign)
        {
            return new MenuWebPart(wp, cp, isDesign, module);
        }

        public override EditWebPart GetWebPartEditControl()
        {
            return new MenuEditControl();
        }
    }

When creating a new child of class of WPInfo do not forget to define a new unique ID (type guid).

Function GetWebPartInstance returns a new webpart instance. This instance will be inserted into the page.
Function GetWebPartEditControl returns an instance of the control for webpart editing.

 

Create a class for the webpart itself now.

public class MenuWebPart : WebPartBase
{
    public ModuleInterface Module { get; private set; }

    public MenuWebPart() : base()
    { }

    public MenuWebPart(WPBase webPart, ContentPage contentPage, bool isWPDesign, ModuleInterface module)
        : base(webPart, contentPage, isWPDesign)
    {
        this.Module = module;
    }

    public override string Title
    {
        get { return "cs-CZ::Webpart Menu~en-US::Webpart Menu"; }
    }

    public override string Description
    {
        get { return "cs-CZ::Nazev~en-US::Name"; }
    }

    public override string TitleImageUrl
    {
        get { return "./Modules/OG.Menu/Images/menu.png"; }
    }

    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);

    //initialize
    //my_property = (WebPart == null ? null : WebPart.Text1);

    if (IsWpSet())
    {
        Page.ClientScript.RegisterClientScriptInclude("Module_Menu", "./modules/OG.menu/Module_Menu.js");
    }
}

protected override void OnPreRender(EventArgs e)
{
    base.OnPreRender(e);

    try
    {
        if (IsWpSet())
        {
            // your code...

            //insert css file
            //Page.Header.Controls.Add(new LiteralControl("<link href=\"./modules/OG.menu/Module_Menu.css\" rel=\"stylesheet\" type=\"text/css\" />");
        }
    }
    catch (Exception ex)
    {
        Module.Application.OG.Log.WriteException(ex, Module);
        RenderError();
    }

Properties Title, Description and TitleImageUrl displayed in the dialogue window for selection of a new webpart for the page.

Method RenderError writes a standard error message in the page.

Webpart editing

If the webpart is more complex, you may need to create a control element for its configuration.

public class MenuEditControl : EditWebPart
{
    private TextItem ti;

    protected override void OnInit(EventArgs e)
    {
        base.OnInit(e);
        EnsureChildControls();
    }

    protected override void CreateChildControls()
    {
        base.CreateChildControls();

        OGRow ro = new OGRow();
        ro.ID = "ro";
        Controls.Add(ro);

        OGCol co = new OGCol() { ID = "cc1", OneColumn = true };
        ro.Controls.Add(co);


        TitleItem2 titleItem = new TitleItem2();
        titleItem.ID = "titi";
        titleItem.Text = "Definice menu";

        ti = new TextItem();
        ti.ID = "texi";
        ti.Rows = 10;

        OGItem ic = new OGItem(titleItem, ti) { ID = "item" };
        co.Controls.Add(ic);
    }

    public override void LoadWebPart(WPBase wp)
    {
        EnsureChildControls();
        ti.SetData(wp.Text1);
    }

    public override void PreSaveWebPart(WPBase wp)
    {
        EnsureChildControls();
        wp.Text1 = ti.GetDataAsString();
    }

    public virtual void SaveWebPart(WPBase wp)
    {
    }

    public override string GetHelpUrl()
    {
        return "http://www.objectgears.cz";
    }
}

Create controls for editing in the method CreateChildControls.
Method LoadWebPart is used for filling in controls with date from the webpart. If you store webpart data in your custom table, read the data according to the webpart ID here.
Before saving you can save the data from controls into the webpart (variable wp) in the method PreSaveWebPart. You can also save the data in a custom table in the method SaveWebPart.
Function GetHelpUrl returns URL to documentation for the webpart. The documentation is available to users by clicking on the question mark icon in the upper right corner.

Data saving

Webpart configuration data can be saved directly into the webparta data instance (WPBase) or into your custom table. If you use your custom table you have to read the data, update and delete them your self. You can use webpart ID as a link to the webpart.

In case that you do not need any special properties for the configuration, you can use following properties in the webpart.

 

Dato type Property Description
string Text1
Text2
Text3
Text4
Text5
Text6
Text property.
bool Bool1
Bool2
Bool3
Indication Yes/No.
int Int1
Int2
Int3
Integer.
DateTime? DateTime1
DateTime2
DateTime3
Date (nullable).

In order to avoid work with your custom table you can save your configuration into xml and use e.g. property Text1.

Webpart deletion

If you use webpart properties for saving webpart configuration, you do not need to care about deletion. However, if you use your custom table, then it is necessary to implement in the class ModuleInterface methods DeleteWebPartInstance and DeleteWebPartInstances. The first method is called during deletion of a single webpart, the second one during deletion of the whole page.

Therefore, it is necessary to save webpart ID and page ID into your custom table if you use it.

This website is using cookies files to provide services and analyse visits. You agree with that by using this website.     Further information