精华内容
下载资源
问答
  • qt ui网格布局Material-UI Grid Component is the Material-UI (MUI) grid system option. It also has the features and APIs of MUI components that MUI users are familiar with. The question when considering...

    qt ui网格布局

    Material-UI Grid Component is the Material-UI (MUI) grid system option. It also has the features and APIs of MUI components that MUI users are familiar with. The question when considering using MUI Grid is: will this be superior to other grid alternatives?

    Material-UI网格组件是Material-UI(MUI)网格系统选项。 它还具有MUI用户熟悉的MUI组件的功能和API。 考虑使用MUI Grid时的问题是:这将优于其他网格替代方法吗?

    Flexbox, Bootstrap, and CSS Grid have proven their usefulness. Understandably, if you are already using Material-UI components, you may choose to use the Grid simply to maintain look and feel. If not, is the MUI Grid an attractive layout option?

    Flexbox,Bootstrap和CSS Grid已证明其有用性。 可以理解,如果您已经在使用Material-UI组件,则可以选择仅使用Grid来维护外观。 如果不是,那么MUI Grid是有吸引力的布局选项吗?

    In this introduction to the Material-UI Grid I will:

    在对Material-UI网格的介绍中,我将:

    YouTube video version of this article here: https://youtu.be/1hTVO9d7Eg8.

    本文的YouTube视频版本: https : //youtu.be/1hTVO9d7Eg8

    Material-UI网格与Bootstrap的简单布局 (Material-UI Grid vs Bootstrap for a simple fluid layout)

    Both Material-UI Grid and Bootstrap 4 are built using CSS’s Flexbox. Therefore, they can both implement vertical alignment, horizontal alignment, and other features of Flexbox. They also both implement a wrapping container with a 12 “column” system. The similarities are significant, but there are a few notable differences.

    Material-UI Grid和Bootstrap 4都是使用CSS的Flexbox构建的。 因此,它们都可以实现Flexbox的垂直对齐,水平对齐和其他功能。 他们还都实现了带有12个“列”系统的包装容器。 相似之处很明显,但有一些显着差异。

    Material-UI Grid uses two “layout types”: containers and items. A container wraps a group of items, the items have their relative width set with attributes such as xs={6} sm={4} . Sounds kinda familiar.

    Material-UI Grid使用两种“布局类型”:容器和项目。 容器包装一组项目,这些项目的相对宽度设置为xs={6} sm={4}等属性。 听起来有点熟悉。

    Bootstrap has three layout items: containers, rows, and columns. Containers are equivalent in both libraries, and MUI Grid items === columns. The primary layout difference is that Bootstrap wraps each group of columns with <div class=”row”> . At first it seems a bit ‘div soup-y’, but it enables bootstrap to be a bit more controlled when shifting to smaller screen sizes, like so:

    Bootstrap具有三个布局项目:容器,行和列。 容器在两个库和MUI网格项===列中都是等效的。 主要的布局差异是Bootstrap用<div class=”row”>包装每组列。 乍一看似乎有点“ div汤-y”,但当转移到较小的屏幕尺寸时,它使引导程序受到更多控制,例如:

    Image for post
    Bootstrap half row
    引导半排
    <div class="container">
    <div class="row">
    <div class="col-6 col-md-4">
    Item 1
    </div>
    <div class="col-6 col-md-4">
    Item 2
    </div>
    <div class="col-6 col-md-4">
    Item 3
    </div>
    </div>
    <div class="row">
    <div class="col">
    Row 2
    </div>
    </div>
    </div>

    Material-UI Grid can accomplish the same thing, but you’ll have to be more deliberate about the width of subsequent rows:

    Material-UI Grid可以完成相同的操作,但是您必须更加仔细地考虑后续行的宽度:

    Image for post
    MUI Grid
    MUI网格
    <div className={classes.root}>
    <Grid container spacing={3}>
    <Grid item xs={6} sm={4}>
    <Paper className={classes.paper}>Item 1</Paper>
    </Grid>
    <Grid item xs={6} sm={4}>
    <Paper className={classes.paper}>Item 2</Paper>
    </Grid>
    <Grid item xs={6} sm={4}>
    <Paper className={classes.paper}>Item 3</Paper>
    </Grid>
    <Grid item xs={12}>
    <Paper className={classes.paper}>Item 3</Paper>
    </Grid>
    </Grid>
    </div>

    However, it would be challenging to control the spacing in the “wrapped row” in MUI.

    但是,在MUI中控制“包装的行”中的间距将具有挑战性。

    Diving into the docs, Bootstrap offers more robust features than MUI Grid. For example, .order- classes order your components regardless of their order in the HTML. Bootstrap also has its own suite of components, most of which overlap the Material-UI component library.

    深入研究文档,Bootstrap提供了比MUI Grid更强大的功能。 例如, .order-类对组件进行排序,而不考虑它们在HTML中的顺序。 Bootstrap还具有自己的组件套件,其中大多数与Material-UI组件库重叠。

    After exploring, I feel as though MUI is focused on being a component library conceived around the Material Design guidelines. It has a grid layout system simply because it needs one. Bootstrap feels like the opposite: primarily a layout system that happens to have a suite of components packaged with it.

    经过探索,我觉得MUI专注于成为围绕材料设计指南构思的组件库。 它之所以具有网格布局系统,仅仅是因为它需要一个。 Bootstrap的感觉恰恰相反:主要是一个布局系统,碰巧打包了一套组件。

    In summary, Material-UI Grid will feel familiar to you if you have used Bootstrap, and it will likely handle any layout you require. However, if total layout power is your primary concern, then Bootstrap may fit the bill better (and it’s a smaller package size at the time of writing this article).

    总之,如果您使用过Bootstrap,那么Material-UI Grid将使您感到熟悉,并且它可能会处理您需要的任何布局。 但是,如果总布局能力是您的主要考虑因素,那么Bootstrap可能会更适合该账单(在撰写本文时,它的包装尺寸较小)。

    Material-UI与CSS Grid的复杂布局 (Material-UI vs CSS Grid for a complex layout)

    CSS Grid Layout gained support on all major browsers in 2017 and gave web developers a powerful 2-dimensional layout system without needing additional libraries.

    CSS Grid Layout在2017年获得了所有主要浏览器的支持,并为Web开发人员提供了功能强大的二维布局系统,而无需其他库。

    Some strong points of CSS Grid:

    CSS Grid的一些优点:

    • no media queries needed

      无需媒体查询
    • spacing is easy and borders easily styled

      间距容易,边框易于样式
    • it is both easier to precisely position a cell, and then the contents of the cell, no div soup required

      精确定位一个单元格,然后放置单元格的内容都比较容易,不需要div汤
    • One of the biggest benefits is that a cell can be “skipped” like this image fro the Mozilla docs (I’ll demo this below).

      最大的好处之一是可以像从Mozilla文档中看到的图像一样“跳过”单元格(我将在下面进行演示)。

    Spoiler alert: CSS Grid is extremely powerful, and comparing MUI Grid to it is almost an apples-to-oranges comparison. However, people still need to decide which option suits their situation, so let’s build a more advanced UI and explore some differences.

    剧透警报:CSS Grid非常强大,将MUI Grid与它进行比较几乎是苹果到橘子的比较。 但是,人们仍然需要确定哪种选项适合他们的情况,因此让我们构建一个更高级的UI并探讨一些差异。

    Image for post
    Which is which?
    哪一个

    The top is Material-UI Grid, the bottom is CSS Grid. The output is identical, but behind the scenes is a different story.

    顶部是Material-UI网格,底部是CSS网格。 输出是相同的,但在幕后是一个不同的故事。

    Chrome dev tools shows us this handy layout visual when we inspect our CSS Grid.

    当我们检查CSS网格时,Chrome开发工具向我们展示了这种方便的布局视觉效果。

    Image for post
    A grid view of the layout
    布局的网格视图

    To accomplish a grid like this, MUI Grid clocks in at 26+ lines of code (depending on formatting).

    为了完成这样的网格,MUI Grid的时钟必须超过26行(取决于格式)。

    <Paper className={classes.paper}>
    <Grid container>
    <Grid xs={12} align="center">
    <Typography>Title</Typography>
    </Grid>
    <Grid container align="left">
    <Grid item xs>
    <Typography>Top L.</Typography>
    </Grid>
    <Grid container direction="column" item xs={6}>
    <Grid item align="center">
    <Typography>Center Top</Typography>
    </Grid>
    <Grid item align="center">
    <Typography>Center Middle</Typography>
    </Grid>
    <Grid item align="center">
    <Typography>Center Bottom</Typography>
    </Grid>
    </Grid>
    <Grid item xs align="right" style={{
    display: "flex",
    flexDirection: "column",
    justifyContent: "flex-end"
    }}
    >
    <Typography>Bottom R.</Typography>
    </Grid>
    </Grid>
    </Grid>
    </Paper>

    Lots of nesting, lots of thinking, lots of playing with flex to get that “Last Bottom R.” in place.

    大量的嵌套,大量的思考,大量的使用flex来获得“ Last Bottom R”。 到位。

    Here’s the CSS Grid version. I still use MUI’s Typography component. This can be reduced to about 12 lines of JSX plus several lines of styling, although for formatting it is longer here.

    这是CSS Grid版本。 我仍然使用MUI的Typography组件。 可以将其减少为大约12行JSX,外加几行样式,尽管在格式化时它更长。

    <Paper
    className={`${classes.paper} ${classes.gridWrapper}`}
    style={{ marginTop: 12 }}
    >
    <Typography
    style={{ gridArea: "title", textAlign: "center", marginBottom: 12 }}
    >
    Title
    </Typography>
    <Typography style={{ gridArea: "a1" }}>
    First Top L.
    </Typography>
    <Typography style={{ gridArea: "a2", textAlign: "center" }}>
    Center Top
    </Typography>
    <Typography style={{ gridArea: "b2", textAlign: "center" }}>
    Center Middle
    </Typography>
    <Typography style={{ gridArea: "c2", textAlign: "center" }}>
    Center Bottom
    </Typography>
    <Typography style={{ gridArea: "c3", textAlign: "right" }}>
    Last Bottom R.
    </Typography>
    </Paper>//styles
    gridWrapper: {
    display: "grid",
    gridTemplateAreas: `
    "title title title"
    "a1 a2 a3"
    "b1 b2 b3"
    "c1 c2 c3"
    `,
    gridTemplateColumns: "repeat(3, minmax(0, 1fr))"
    }

    Take a look at the bottom of that code snippet…the gridTemplateAreas in the gridWrapper class is the key to creating your layout. It is working code but it also provides a visual for the grid layout.

    看看该代码段的底部……gridWrapper类中的gridTemplateAreas是创建布局的关键。 它是有效的代码,但也提供了网格布局的外观。

    Also, notice how you can omit cells that are not needed, i.e. there is no cell for gridArea: “a3”. This is a pretty sweet feature.

    另外,请注意如何省略不需要的单元格,即gridArea没有单元格:“ a3”。 这是一个非常不错的功能。

    为Material-UI网格和CSS网格添加边框 (Add border to Material-UI Grid and CSS Grid)

    I will just give a quick highlight of the code for how to create borders for an MUI Grid and a CSS Grid. If you want full code, see this CodeSandbox.

    我将简要介绍一下如何为MUI网格和CSS网格创建边框的代码。 如果您需要完整的代码,请参阅此CodeSandbox

    To add a border around every cell and make MUI Grid look like, well, a grid, I added back any “missing” cells and I added the following CSS:

    为了在每个单元格周围添加边框并使MUI Grid看起来像网格,我添加了所有“缺失”的单元格,并添加了以下CSS:

    outerColumn: {
    borderRight: "1px solid grey",
    borderBottom: "1px solid grey",
    borderLeft: "1px solid grey"
    },
    centerColumn: {
    borderBottom: "1px solid grey"
    }

    The left and right columns of three cells each got the outerColumn class, while the inner column of three cells got the centerColumn class. Pretty straightforward.

    每三个单元格的左,右列得到了outerColumn类,而三格内柱得到了centerColumn类。 非常简单。

    The CSS Grid was more elegant, really. I added in any missing cells, but then instead of a new CSS class, I simply updated the gridWrapper class:

    实际上,CSS Grid更优雅。 我添加了所有缺少的单元格,但是然后我没有更新新CSS类,而是简单地更新了gridWrapper类:

    gridWrapper: {
    border: "1px solid grey",
    display: "grid",
    backgroundColor: "grey",
    gridRowGap: 1,
    gridColumnGap: 1,
    gridTemplateAreas: `
    "title title title"
    "a1 a2 a3"
    "b1 b2 b3"
    "c1 c2 c3"
    `,
    gridTemplateColumns: "repeat(3, minmax(0, 1fr))",
    "& > *": {
    backgroundColor: "white"
    }
    }

    Instead of creating external borders, I created a grey background in the grid container, gave the individual cells a white background, and then added a 1px row and column gap to let the grey background show through. Sweet!

    我没有创建外部边框,而是在网格容器中创建了灰色背景,为单个单元格提供了白色背景,然后添加了1px的行和列间距以使灰色背景得以显示。 甜!

    何时使用Material-UI网格(以及何时使用其他布局选项) (When to use Material-UI Grid (and when to use a different layout option))

    I think a fair conclusion from these comparisons is that Material-UI grid is best for a situation where you need simple layouts, you want to stay within the Material-UI world, or you want the grid to inherit the MUI theme provided in your app.

    我认为从这些比较中得出的一个合理的结论是,Material-UI网格最适合需要简单布局,希望保留在Material-UI世界中或者希望网格继承应用程序中提供的MUI主题的情况。

    I believe in most situations, you can get the job done with MUI Grid, but you could likely do it with cleaner or more intuitive code if you use CSS Grid or Bootstrap.

    我相信在大多数情况下,可以通过MUI Grid来完成工作,但是如果使用CSS Grid或Bootstrap,则可以使用更简洁或更直观的代码来完成。

    Are you a developer looking to start your first side hustle? Learn how here.

    您是否正在寻找开始第一手的开发人员? 在这里了解如何

    翻译自: https://medium.com/the-clever-dev/intro-to-material-ui-grid-component-ecc553a93200

    qt ui网格布局

    展开全文
  • 网格布局

    2016-03-08 20:20:09
    GridLayout的作用类似于HTML中的table标签,它把整个容器划分为rowsXcolumns个网格,每个网格可以放置一个组件。 除此之外,也可以设置一个组件横跨多少列、一个组件纵跨多少行。 实例:计算器界面 下面先...

    网格布局由GridLayout所代表,它是Android4.0新增的布局管理器。

    GridLayout的作用类似于HTML中的table标签,它把整个容器划分为rowsXcolumns个网格,每个网格可以放置一个组件。

    除此之外,也可以设置一个组件横跨多少列、一个组件纵跨多少行。


    实例:计算器界面

    下面先定义界面布局文件

    <?xml version="1.0" encoding="utf-8"?>
    <GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        app:layout_behavior="@string/appbar_scrolling_view_behavior"
        tools:context="com.example.l2112.wanggebuju.MainActivity"
        tools:showIn="@layout/activity_main"
        android:id="@+id/hello"
        android:rowCount="6"
        android:columnCount="4">
        <!-- 定义一个横跨4列的文本框,并设置该文本框的背景色、前景色等属性 -->
        <TextView
            android:id="@+id/hello1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_columnSpan="4"
            android:textSize="50sp"
            android:layout_marginLeft="2pt"
            android:layout_marginRight="2pt"
            android:padding="3pt"
            android:layout_gravity="right"
            android:background="#eee"
            android:text="0"/>
        <!-- 定义一个横跨4列的按钮 -->
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_columnSpan="4"
            android:text="清除"/>
    
    </GridLayout>
    
    接下来使用如下Java代码采用循环控制添加16个按钮。

    package com.example.l2112.wanggebuju;
    
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.Snackbar;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.Gravity;
    import android.view.View;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.widget.Button;
    import android.widget.GridLayout;
    
    public class MainActivity extends AppCompatActivity {
        GridLayout gridLayout;
        //定义16个按钮的文本
        String[] chars = new String[]{
                "7","8","9","÷",
                "4","5","6","x",
                "1","2","3","-",
                ".","0","=","+"
        };
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
            setSupportActionBar(toolbar);
    
            FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                            .setAction("Action", null).show();
                }
            });
            gridLayout = (GridLayout)findViewById(R.id.hello);
            for(int i = 0;i < chars.length;i++)
            {
                Button bn = new Button(this);
                bn.setText(chars[i]);
                //设置该按钮的字号大小
                bn.setTextSize(40);
                //设置按钮四周的空白区域
                bn.setPadding(5,35,5,35);
                //指定该组件所在的行
                GridLayout.Spec rowSpec = GridLayout.spec(i/4+2);
                //指定该组件所在的列
                GridLayout.Spec columnSpec = GridLayout.spec(i%4);
                GridLayout.LayoutParams params = new GridLayout.LayoutParams(rowSpec,columnSpec);
                //指定该组件占满父容器
                params.setGravity(Gravity.FILL);
                gridLayout.addView(bn,params);
            }
        }
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.menu_main, menu);
            return true;
        }
    
        @Override
        public boolean onOptionsItemSelected(MenuItem item) {
            // Handle action bar item clicks here. The action bar will
            // automatically handle clicks on the Home/Up button, so long
            // as you specify a parent activity in AndroidManifest.xml.
            int id = item.getItemId();
    
            //noinspection SimplifiableIfStatement
            if (id == R.id.action_settings) {
                return true;
            }
    
            return super.onOptionsItemSelected(item);
        }
    }
    



    展开全文
  • Android五大布局之网格布局

    千次阅读 2015-10-19 22:58:32
    GridLayout的作用类似HTML中的table标签,它把整个容器rows * columns个网格,每个网格可以放置一个组件。除此之外,也可以设置一个组件横跨多少列,一个组件横跨多少行。为了控制GridLayout布局容器中各个子组件的...

    网格布局由GridLayout所代表,它是Android 4.0 新增的布局管理器,因此需要在Android 4.0之后的版本中才能使用此布局管理器。

    GridLayout的作用类似HTML中的table标签,它把整个容器rows * columns个网格,每个网格可以放置一个组件。除此之外,也可以设置一个组件横跨多少列,一个组件横跨多少行。

    为了控制GridLayout布局容器中各个子组件的布局分布,GridLayout提供一个内部类:GridLayout.LayoutParams,该类提供了大量的XML属性来控制GridLayout布局容器中子组件的布局分布。下面为其常用的XML属性相关方法。

    android:layout_column 设置该子组件在GridLayout的第几列
    android:layout_columnSpan 设置该子组件在GridLayout横向上跨几列
    android:layout_gravity 设置该子组件采用何种方式占据该网格
    android:layout_row 设置该子组件在GridLayout的第几行
    android:layout_rowSpan 设置该子组件在GridLayout纵向上跨几行。

    实例代码:

    <?xml version="1.0" encoding="utf-8"?>
    
    <GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:rowCount="6"
        android:columnCount="4"
        android:id="@+id/root">
    
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_columnSpan="4"
            android:textSize="40sp"
            android:layout_marginLeft="2pt"
            android:layout_marginRight="2pt"
            android:padding="3pt"
            android:background="#eee"
            android:textColor="#000"
            android:text="0"/>
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_columnSpan="4"
            android:text="清除"/>
    
        <Button 
            android:text="7"/>
    
        <Button 
            android:text="8"/>
    
        <Button 
            android:text="9"/>
    
        <Button 
            android:text="/"/>
    
        <Button 
            android:text="4"/>
    
        <Button 
            android:text="5"/>
    
        <Button 
            android:text="6"/>
    
        <Button 
            android:text="*"/>
    
        <Button 
            android:text="1"/>
    
        <Button 
            android:text="2"/>
    
        <Button 
            android:text="3"/>
    
        <Button 
            android:text="-"/>
    
        <Button 
            android:text="."/>
    
        <Button 
            android:text="0"/>
    
        <Button 
            android:text="="/>
    
        <Button 
            android:text="+"/>
    
    </GridLayout>

    运行结果:
    这里写图片描述

    看到的朋友麻烦你们给我解释下为什么”/”,”*”,”-“,”+”这一列显示不完全。
    谢谢

    展开全文
  • Grid网格布局

    2021-08-08 13:15:56
    CSS Grid 网格布局可以将网格元素放置在与这些行和列相关的位置上,进而快速、便捷的对页面结构进行布局,提高工作效率 “flexbox” 是一维的布局,是因为一个 “flexbox container” 一次只能处理一个维度上的元素...

    CSS Grid(网格) 布局

    CSS Grid 网格布局可以将网格元素放置在与这些行和列相关的位置上,进而快速、便捷的对页面结构进行布局,提高工作效率

    “flexbox” 是一维的布局,是因为一个 “flexbox container” 一次只能处理一个维度上的元素布局,一行或者一列。

    相比较 “Grid网格布局”,则是二维布局可以同时处理行和列上的布局

    通常适用于布局页面主要的区域布局或小型组件

     

    兼容

    ie10、ie11支持带前缀-ms-

     

    基本概念

    容器与项目

    采用网格布局的区域,称为"容器"(container)。 容器内部采用网格定位的子元素,称为"项目"(item)。

     

    行和列

    容器里面的水平区域称为"行"(row),垂直区域称为"列"(column)。

     

    单元格

    行和列的交叉区域,称为"单元格"(cell)

    正常情况下,n行和m列会产生n x m个单元格。比如,3行3列会产生9个单元格。

     

    正常情况下,n行和m列会产生n x m个单元格。比如,3行3列会产生9个单元格。

    网格线

    划分网格的线,称为"网格线"(grid line)。 水平网格线划分出行,垂直网格线划分出列。

     

    正常情况下,n行有n + 1根水平网格线,m列有m + 1根垂直网格线,
    比如三行就有四根水平网格线。

    网格属性

    Grid 布局的属性分成两类。 一类定义在容器上面,称为容器属性; 另一类定义在项目上面,称为项目属性。

    容器属性

    设置为网格布局

    • 设置为块级网格

    div {
      display: grid;
    }
    • 设置为行级网格

    div {
      display: inline-grid;
    }

    注意

    • 不是网格的直接子元素,不参与网格布局

    • 设为网格布局以后,容器子元素(项目)的float、display: inline-block、vertical-align和column-*等设置都将失效。

    列宽与行高

    grid-template-columns网格布局中列的数量(和宽度)

    grid-template-rows网格布局中行的数量(和高度)

    语法

    • 空格隔开的一组值列表

    • 其中每个值指定相应列的宽度/行的高度。

    取值

    • 默认值 none

    • 绝对单位px

      grid-template-columns: 100px 100px 100px;
      grid-template-rows: 100px 100px 100px;
    • 百分比

      .container {
        display: grid;
        grid-template-columns: 33.33% 33.33% 33.33%;
        grid-template-rows: 33.33% 33.33% 33.33%;
      }
    • fr 关键字

      fraction 的缩写,意为部分
      • 弹性系数,按比例分配剩余空间(如果两列的宽度分别为1fr和2fr,就表示后者是前者的两倍)

      • 可以与绝对长度的单位结合使用

    • auto 关键字

      关键字表示由浏览器自己决定长度

      grid-template-columns: 100px auto 100px;
    • minmax()

      • 函数产生一个长度范围,表示长度就在这个范围之中。它接受两个参数,分别为最小值和最大值

        即空间不足时以最小以min显示,空间有剩余时最大按max显示

        • 注意:如果max值小于min值,则该值会被视为min值。最大值可以设置为fr但最小值则不行

        grid-template-columns: 1fr 1fr minmax(100px, 1fr);
        minmax(100px, 1fr)表示列宽不小于100px,不大于1fr。
    • repeat( )函数

      • 作用:简化重复的值

      • 接受两个参数,第一个参数是重复的次数,第二个参数是所要重复的值

        repeat(重复的次数,一个或空格隔开的多个值 )
        
        grid-template-columns: repeat(2, 100px);表示共两列,每列各100px
      • 第二个参数为空格隔开的多个值 时表示,重复某种模式。

      grid-template-columns: repeat(2, 100px 20px 80px);
      定义了6列,第一列和第四列的宽度为100px,第二列和第五列为20px,第三列和第六列为80px。
    • auto-fill 关键字

      【单元格的大小是固定的,但是容器的大小不确定。如果希望每一行(或每一列)容纳尽可能多的单元格时使用】

       grid-template-columns:repeat(auto-fill,100px);
       表示每列宽度100px,然后自动填充,直到容器不能放置更多的列。

    设置行与行的间隔(行间距)

    column-gap属性设置列与列的间隔(列间距)

    row-gap属性设置行与行的间隔(行间距)

    取值

    • 默认值 0

    • px

    • 百分比(相对于容器)

    简写grid-gap

    • gap: 行间距 列间距; 【空格】隔开

    • 省略了第二个值,浏览器认为第二个值等于第一个值

    单元格在容器垂直位置,水平位置

    justify-content水平位置 总网格区域相对于容器左右对齐方式(网格内容大小小于容器宽时) align-content 位置 总网格区域相对于容器上下对齐方式(网格内容大小小于容器高时)

     

    取值

    • start - 对齐容器的起始边框。

    • end - 对齐容器的结束边框。

    • center - 容器内部居中。

    • stret ch - 列宽或行高为auto时有效

    • space-around - 单元格两侧间隔相等。所以,单元格之间的间隔比单元格与容器边框的间隔大一倍。

    • space-between - 剩余空间分布在单元格之间,单元格与容器边框之间没有间隔。

    • space-evenly - 剩余空间均等分布在单元格与单元格,单元格与项目之间。单元格与容器边框之间间隔相等

    简写

    place-content属性是align-content属性和justify-content属性的合并简写形式。

    • place-content:垂直 水平 【空格】隔开

    • 如果省略第二个值,浏览器就会假定第二个值等于第一个值。

    项目(内容)在单元格中的垂直、水平位置

    justify-self 水平位置:内容相对于单元格左右对齐方式(通常项目内容大小小于单元格宽度时)

    align-self 垂直位置:内容相对于单元格上下对齐方式(通常项目内容大小小于单元格高度时)

    取值

    • start:对齐单元格的起始边缘。

    • end:对齐单元格的结束边缘。

    • center:单元格内部居中。

    • stretch:拉伸,占满单元格的整个宽度(默认值)

    •  

    简写

    place-self属性是align-self属性和justify-self属性的合并简写形式。

    • place-self: 垂直 水平; 【空格隔开】

    • 如果省略第二个值,则浏览器认为与第一个值相等。

    项目放置顺序

    划分网格以后,容器的子元素会按照顺序,自动放置在每一个网格。默认的放置顺序是"先行后列",即先填满第一行,再开始放入第二行

    grid-auto-flow 属性

    • 默认值是row,即"先行后列"。

    • column,变成"先列后行"。

    • 使用之前grid-template-columns和grid-template-rows必须都设置

    网格项命名(给网格划分区域)

    网格布局允许指定"区域"(area),一个区域由单个或多个单元格组成

    通过grid-template-areas 属性实现

    取值

    • 默认值 none

    • 一个双引号一行,一个空格一列

      grid-template-areas: 
                           "种花 养鱼 菠菜"
                           "西瓜 冬瓜 南瓜";
    • 多个单元格合并成一个区域的写法

      grid-template-areas: 'a a a'
                           'b c c'
                           'd d d';
    • 某些区域不需要利用,则使用"点"(.)表示。

      .wrap {
      width: 300px;
      height: 300px;
      border: 1px solid #000;
      
      display: grid;
      grid-template-rows: repeat(3, 100px);
      grid-template-columns: repeat(3, 100px);
      grid-template-areas: "a a a"
      					 "b . c"
      					 "d d d";
      
      margin:20px auto;
      }
      
      .header{
          background-color: orange;
          grid-area:a;
      }
      .side{
          background-color: yellowgreen;
          grid-area:b;
      }
      .main{
          background-color: #ccc;
          grid-area:c;
      }
      .footer{
          background-color: pink;
          grid-area:d;
      }
            
            
       <div class="wrap">
              <div class="header">header</div>
              <div class="main">main</div>
              <div class="side">side</div>
              <div class="footer">footer</div>
       </div>
      
             

       

    项目属性

    grid-area指定项目具体显示区域

    可以通过网格区域名指定,也可以通过指定四条组成网格区域的网格线确定。

    取值:

    • none 默认值。 没有命名的网格区域

    • 网格区域名(指定使用grid-template-areas属性自定义一些网格区域)

    • 通过指定grid子项所占据的区域的起始和终止位置

      • grid-column-start属性:左边框所在的垂直网格线

      • grid-column-end属性:右边框所在的垂直网格线

      • grid-row-start属性:上边框所在的水平网格线

      • grid-row-end属性:下边框所在的水平网格线

      简写

      • grid-column属性是grid-column-start和grid-column-end的合并简写形式

      • grid-row属性是grid-row-start属性和grid-row-end的合并简写形式。

        • 以斜杠分割 开始/结束

        • 斜杠以及后面的部分可以省略,默认跨越一个网格。

    .item-1 {
      grid-column: 1 / 3;
      grid-row: 1 / 2;
    }
    /* 等同于 */
    .item-1 {
      grid-column-start: 1;
      grid-column-end: 3;
      grid-row-start: 1;
      grid-row-end: 2;
    }
    item-1 {
      background: #b03532;
      grid-column: 1 / 3;
      grid-row: 1 / 3;
    }
    /* 等同于 */
    .item-1 {
      background: #b03532;
      grid-column: 1 / span 2;
      grid-row: 1 / span 2;
    }

    注:如果项目指定的网格区域是重叠的可以使用z-index 进行调整层级

    单独指定单元素格内容的对齐

    justify-self属性设置单元格内容的水平位置(左中右)

    align-self属性设置单元格内容的垂直位置(上中下)

    • start:对齐单元格的起始边缘。

    • end:对齐单元格的结束边缘。

    • center:单元格内部居中。

    • stretch:拉伸,占满单元格的整个宽度(默认值)  

    简写

    • place-self属性是align-self属性和justify-self属性的合并简写形式。

    • 如果省略第二个值,place-self属性会认为这两个值相等

    展开全文
  • 网格布局GridLayout

    2014-12-22 11:22:09
     GridLayout的作用类似于HTML中的table标签,它把整个容器划分成rowsxcolumns个网格,每个网格可以放置一个组件。  初次之外,也可以设置一个组件横跨多少列、一个组件纵跨多少行。  GridLa
  • JavaSwing_1.2: GridLayout(网格布局

    万次阅读 多人点赞 2017-05-30 23:55:57
    它以矩形网格形式对容器的组件进行布置,把容器按行列分成大小相等的矩形网格,一个网格放置一个组件组件宽高自动撑满网格。以行数和总数优先: 通过构造方法或 setRows 和 setColumns 方法将行数和列数设置为...
  • GridLayout网格布局

    2018-06-28 10:36:00
    网格布局特点: l 使容器中的各组件呈M行×N列的网格状分布。 l 网格列宽度相同,等于容器的宽度除以网格的列数。 l 网格行高度相同,等于容器的高度...l 设置网格布局行数和列数时,行数或者列数可以有一个...
  • 介绍 网格布局管理器是在 Android 4.0 版本中提出...在网格布局管理器中,屏幕被虚拟的细线划分成行、列和单元格,每个单元格放置一个组件,并且这个组件也可以跨行或跨列摆放,如图 3.24 所示。 XML属性 例子 ...
  • 使用 display: grid 或 display: inline-grid 创建网格容器。 使用 grid-template-columns 和 grid-template-rows 设置行和列。 使用 grid-auto-colums 和 grid-auto-rows 属性设置隐式轨道(implicit tracks)的...
  • 使用的教材是java核心技术卷1,我将跟着这本书的章节同时配合视频资源来进行学习基础java知识。 day076 Swing用户界面组件(二:布局管理概述)(边框布局、网格布局) ...
  • css 网格布局 This article was updated in July, 2018 to reflect improved browser support for CSS Grid Layout. 本文于2018年7月进行了更新,以反映出改进的浏览器对CSS Grid Layout的支持。 As web ...
  • 3.网格布局

    2021-09-03 23:03:59
    它是一个二维系统,这意味着它既可以处理列又可以处理行,而 flexbox 很大程度上是一维系统。通过将CSS规则应用于父元素(成为 Grid 容器)和该元素的子元素(成为 Grid Items),使用 Grid 布局。 注意: Flexbox...
  • 网格布局介绍:GridLayout布局将容器分割成多行多列,组件被填充到每个网格中,添加到容器中的组件首先放置在左上角的网格中,然后从左到右放置其他的组件,当占满该行的所有网格后,接着继续在下行从左到右放置...
  • CSS Grid网格布局详解

    2019-08-24 16:06:08
    Grid 布局又称网格布局,是W3C提出的一个二维布局系统,它与 Flex 布局有一定的相似性,可以指定容器内部多个项目的位置。但是,它们也存在重大区别。Flex 布局是轴线布局,只能指定"项目"针对轴线的位置,可以...
  • JAVA网格布局管理器

    2019-10-09 20:39:33
    网格布局管理器中,每一个组件的大小相同,并且网格中空格的个数由网格的行数和列数决定,如一个两行两列的网格产生4个大小相等的网格。组件从网格的左上角开始,按照从左到右、从上到下的顺序加入到网格中,...
  • 文章目录1 Android 用户界面1.1 Android UI元素1.2 视图容器1.3 组件的宽高...weight 使用比例3.3 空间位置以及内容位置4 网格布局 - GridLayout4.1 网格布局定位4.2 使用跨行与跨列的属性 1 Android 用户界面 1.1 An
  • 当向使用 GridLayout 布局管理器的容器中添加组件时, 默认从左向右、 从上向下依次添加到每个网格中 。 与 FlowLayout不同的是,放置在 GridLayout 布局管理器中的各组件的大小由组件所处的区域决定(每 个组件将...
  • GridLayout 将容器切割为棋盘一样m行n列的网格,每个网格可以放置一个组件,添加到容器的组件从左向右自上而下依次放置。 GridLayout 最大的特点是放置组件自动占据网格的整个区域,每个组件的大小相同,不改变组件...
  • 网格布局管理器是Android4.0提出的,使用GridLayout表示,在网格布局管理器中,屏幕被虚拟的细线划分成行,列和单元格,每个单元格放置一个组件,并且这个组件也可以跨行或跨列摆放 网格布局管理器和表格布局管理器的区别:...
  • 网格布局由GridLayout代表,它是Android4.0新增的布局管理器,因此...GridLayout的作用类似于HTML中的table标签,它把整个容器划分成rows*columns个网格,每个网格可以放置一个组件。除此之外,也可以设置一个组件横跨
  • 网格布局由GridLayout代表,它是Android4.0新增的布局
  • 网格布局特点: l 使容器中的各组件呈M行×N列的网格状分布。 l 网格列宽度相同,等于容器的宽度除以网格的列数。 l 网格行高度相同,等于容器的高度...l 设置网格布局行数和列数时,行数或者列数可以有一个
  • css 网格布局I am having a lot of fun answering questions as people start to figure out CSS Grid Layout. In doing so it has started to become obvious that many people are expecting the CSS Grid Layout ...
  • 但他更加灵活,在网格布局中,屏幕被分成很多行与列形成的单元格(可以自定义网格布局有多少行,多少列),每个单元格可以放置一个控件或者布局布局管理器,他的优势在于,不仅可以跨行,还可以跨列摆放组件。...
  • 在安卓中提供了几常用布局: LinearLayout线性布局 ...GridLayout网格布局 TableLayout表格布局 TableLayout的介绍 TableLayout是将子类向分别排列成行和列的布局视图容器,Table...
  • 网格布局是Android4.0新增的布局管理器,... GridLayout的作用类似于HTML中的table标签,它把整个容器划分成row*column个网格,每个网格都可以放置一个组件,也可以设置一个组件横跨多少列、多少行。 GridLayou...
  • jQuery mobile网格布局

    千次阅读 2014-03-20 15:16:22
    jQuery Mobile中提供了许多非常有用的工具与组件,如多列的网格布局、折叠形的面板控制等,这些组件可以帮助开发者快速实现正文区域内容的格式化。 3.4.1 网格布局 jQuery Mobile提供的CSS样式“ui-grid”...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,533
精华内容 2,213
关键字:

网格布局每个网格都能放置一个组件